@ubox-tools/deploy-xperience 1.0.0

package/README.md

@@ -0,0 +1,119 @@
+# deploy.js
+
+Automated deployment script for Ubox experiences. Uses Puppeteer to drive the Ubox Studio web interface and deploy apps and Uboxes without manual browser interaction.
+
+> **Run from the project root.** Always invoke `npx @ubox-tools/deploy-xperience` from the experience directory (the one containing `apps/` and `assets/`).
+
+## Requirements
+
+- Node.js 18+
+- A clipboard utility — only needed when the Monaco/CodeMirror editor API is unavailable:
+  - **macOS**: `pbcopy` (built-in)
+  - **Windows**: PowerShell `Set-Clipboard` or `clip.exe` (both built-in)
+  - **Linux**: `wl-copy` (Wayland), `xclip` (X11), or `xsel` (X11)
+
+## Usage
+
+```
+npx @ubox-tools/deploy-xperience [app1 app2 ...] [options]
+```
+
+## Options
+
+| Flag | Description |
+|---|---|
+| `--email <email>` | Ubox Studio login email (or `UBOX_EMAIL` env var) |
+| `--password <pass>` | Ubox Studio password (or `UBOX_PASSWORD` env var) |
+| `--project-name <name>` | Override the project name (default: parent directory name) |
+| `--noassets` | Skip uploading assets (images, fonts, files) |
+| `--noplayer` | Skip Phase 3 — deploy apps only, do not create/update Uboxes |
+| `--show` | Show the browser window (default: headless) |
+| `--help` | Print usage and exit |
+
+Credentials can also be supplied via environment variables:
+
+```
+UBOX_EMAIL=me@example.com UBOX_PASSWORD=secret npx @ubox-tools/deploy-xperience
+```
+
+If either credential is missing and the terminal is interactive, the script prompts for them.
+
+## Examples
+
+```bash
+npx @ubox-tools/deploy-xperience                        # Deploy all apps (headless)
+npx @ubox-tools/deploy-xperience --show                 # Deploy all apps, show browser
+npx @ubox-tools/deploy-xperience mobile                 # Deploy only the mobile app
+npx @ubox-tools/deploy-xperience main --noassets        # Deploy main app, skip asset uploads
+npx @ubox-tools/deploy-xperience --noplayer             # Deploy apps only, skip Uboxes
+npx @ubox-tools/deploy-xperience --project-name "MyProject"
+```
+
+## Deployment Phases
+
+### Phase 1 — Login
+
+Navigates to `studio.ubox.world` and signs in. Skipped automatically if a session is already active.
+
+### Phase 2 — Application Deployment
+
+Runs once per app (always `mobile` before `main`):
+
+1. **Find or create** the application card by its full name (`<ProjectName> <appName>`).
+2. **Upload resources** — groups assets by type (Images / Fonts / Files), deletes any existing file with the same name first, then uploads via CDP (bypasses the OS file picker dialog).
+3. **Configure parameters** — reads `apps/<appName>/parameters.json`; only creates parameters that don't already exist.
+4. **Inject source** — opens the Source editor, iterates the tab list (`HTML`, `CSS`, `Ubox Events`, `Workflow`, `Business logic`, `Data source`) and sets each file's content via the Monaco or CodeMirror API, or via clipboard paste as a fallback.
+
+### Phase 3 — Ubox Deployment
+
+Runs once per app:
+
+1. **Find or create** the Ubox by its full name. Handles the Terms & Conditions modal on first creation.
+2. **Check "Make public"** — enables the public checkbox if not already checked.
+3. **Install app** — switches to the "Available applications" tab, searches for the app card, and clicks Install.
+4. **Mobile virtual link** — for the `mobile` app, clicks "Open Virtual Ubox Link" and captures the URL from the newly opened tab.
+5. **Set `mobileLink` parameter** — for the `main` Ubox (if the app defines a `mobileLink` parameter), opens "Change params" and writes the captured mobile virtual link.
+
+If the Ubox already exists, installation and parameter changes are skipped; the mobile virtual link is still retrieved so the main Ubox can use it.
+
+## Proxy / Source Transformation
+
+Before injecting source files, `generateProxy()` applies three transforms to each file:
+
+| Transform | Applies to | What it does |
+|---|---|---|
+| Parameter substitution | JS | Replaces `const KEY = "value"` with `const KEY = "{parameter:KEY}"` for every key in `parameters.json` |
+| Asset path substitution | JS, CSS | Replaces `../assets/file.ext` references with `{resources:type/file.ext}` tokens |
+| Emoji escaping | JS | Converts non-ASCII characters to `\uXXXX` Unicode escape sequences |
+| Local tag stripping | HTML | Removes local `<link href>` and `<script src>` tags (CDN URLs are kept) |
+
+## Project Layout Expected
+
+```
+<project-root>/
+  apps/
+    mobile/
+      index.html
+      style.css
+      ubox.js
+      workflow.js
+      logic.js
+      data.js
+      parameters.json   (optional)
+    main/
+      ...same files...
+  assets/
+    *.jpg / *.png / *.woff2 / ...
+  deploy.js
+```
+
+The project name defaults to the directory name of `<project-root>`. App full names are formed as `"<projectName> <appName>"` (e.g. `"Claude - Slide Puzzle mobile"`).
+
+## Error Handling
+
+On any unhandled error the script:
+1. Prints the error message.
+2. Saves a screenshot to `deploy_error.png` in the project root.
+3. Exits with code 1.
+
+The browser is kept open after both success and failure so you can inspect the final state. Press `Ctrl+C` to close it.

package/deploy.js

@@ -0,0 +1,1079 @@
+'use strict';
+
+const puppeteer        = require('puppeteer');
+const path             = require('path');
+const fs               = require('fs');
+const readline         = require('readline');
+const { spawnSync }    = require('child_process');
+
+// ─── Constants ────────────────────────────────────────────────────────────────
+
+const PROJECT_ROOT  = process.cwd();
+const APPS_DIR      = path.join(PROJECT_ROOT, 'apps');
+const ASSETS_DIR    = path.join(PROJECT_ROOT, 'assets');
+const BASE_URL      = 'https://studio.ubox.world';
+const PROJECT_NAME  = path.basename(PROJECT_ROOT); // "Claude - Slide Puzzle"
+const DEPLOY_ORDER  = ['mobile', 'main'];
+
+// File → editor tab label mapping
+const TAB_MAP = {
+  'index.html' : 'HTML',
+  'style.css'  : 'CSS',
+  'ubox.js'    : 'Ubox Events',
+  'workflow.js': 'Workflow',
+  'logic.js'   : 'Business logic',
+  'data.js'    : 'Data source',
+};
+
+// Asset file extension → resource sub-tab
+const ASSET_TYPES = {
+  jpg: 'images', jpeg: 'images', png: 'images', gif: 'images', webp: 'images', svg: 'images',
+  woff: 'fonts', woff2: 'fonts', ttf: 'fonts', otf: 'fonts', eot: 'fonts',
+};
+
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+// ─── CLI Parsing ──────────────────────────────────────────────────────────────
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+Usage: npx @ubox-tools/deploy-xperience [app1 app2 ...] [options]
+
+Apps (default: all apps in apps/, always mobile before main):
+  mobile           Deploy mobile app
+  main             Deploy main app
+
+Options:
+  --email <email>        Ubox studio email (or set UBOX_EMAIL env var)
+  --password <pass>      Ubox studio password (or set UBOX_PASSWORD env var)
+  --project-name <name>  Override project name (default: directory name)
+  --noassets             Skip uploading assets (resources)
+  --noplayer             Skip Ubox creation (Phase 3) — only deploy applications
+  --show                 Show the browser window (default: headless)
+  --help                 Show this help
+
+Examples:
+  npx @ubox-tools/deploy-xperience                   # Deploy all apps
+  npx @ubox-tools/deploy-xperience mobile            # Deploy only mobile
+  npx @ubox-tools/deploy-xperience main              # Deploy only main
+  npx @ubox-tools/deploy-xperience --noassets        # Deploy without re-uploading assets
+  npx @ubox-tools/deploy-xperience --noplayer        # Deploy apps only, skip Uboxes
+  UBOX_EMAIL=me@x.com npx @ubox-tools/deploy-xperience
+`.trim());
+    process.exit(0);
+  }
+
+  let email       = process.env.UBOX_EMAIL;
+  let password    = process.env.UBOX_PASSWORD;
+  let projectName = null;
+  let noAssets    = false;
+  let noPlayer    = false;
+  let show        = false;
+  const appArgs   = [];
+
+  for (let i = 0; i < args.length; i++) {
+    if      (args[i] === '--email')        { email = args[++i]; }
+    else if (args[i] === '--password')     { password = args[++i]; }
+    else if (args[i] === '--project-name') { projectName = args[++i]; }
+    else if (args[i] === '--noassets')     { noAssets = true; }
+    else if (args[i] === '--noplayer')     { noPlayer = true; }
+    else if (args[i] === '--show')         { show = true; }
+    else if (!args[i].startsWith('--'))    { appArgs.push(args[i]); }
+  }
+
+  // Discover available apps from apps/ directory
+  const available = fs.existsSync(APPS_DIR)
+    ? fs.readdirSync(APPS_DIR).filter(d => fs.statSync(path.join(APPS_DIR, d)).isDirectory())
+    : [];
+
+  // Respect DEPLOY_ORDER (mobile → main), then any extras
+  const base     = DEPLOY_ORDER.filter(a => available.includes(a));
+  const extras   = available.filter(a => !DEPLOY_ORDER.includes(a));
+  const allApps  = [...base, ...extras];
+  const selected = appArgs.length > 0 ? appArgs : allApps;
+
+  // Always keep mobile before main regardless of user input order
+  const ordered = [
+    ...DEPLOY_ORDER.filter(a => selected.includes(a)),
+    ...selected.filter(a => !DEPLOY_ORDER.includes(a)),
+  ];
+
+  return { apps: ordered, email, password, projectName, noAssets, noPlayer, show };
+}
+
+// ─── Credentials ──────────────────────────────────────────────────────────────
+
+async function promptCredentials(email, password) {
+  if (email && password) return { email, password };
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  if (!email) {
+    email = await new Promise(resolve => rl.question('Email: ', resolve));
+  }
+
+  if (!password) {
+    password = await new Promise(resolve => {
+      process.stdout.write('Password: ');
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+      }
+      let input = '';
+      process.stdin.resume();
+      process.stdin.setEncoding('utf8');
+      const handler = char => {
+        if (char === '\r' || char === '\n') {
+          if (process.stdin.isTTY) process.stdin.setRawMode(false);
+          process.stdin.pause();
+          process.stdin.removeListener('data', handler);
+          process.stdout.write('\n');
+          resolve(input);
+        } else if (char === '\u0003') {
+          process.exit(1);
+        } else if (char === '\u007F') {
+          if (input.length > 0) { input = input.slice(0, -1); process.stdout.write('\b \b'); }
+        } else {
+          input += char;
+          process.stdout.write('*');
+        }
+      };
+      process.stdin.on('data', handler);
+    });
+  }
+
+  rl.close();
+  return { email, password };
+}
+
+// ─── Proxy File Generation ────────────────────────────────────────────────────
+
+function assetResourceType(ext) {
+  return ASSET_TYPES[ext.toLowerCase()] || 'files';
+}
+
+function escapeEmojiInJS(content) {
+  return content.replace(/[^\x00-\x7F]/g, char => {
+    const cp = char.codePointAt(0);
+    if (cp > 0xFFFF) {
+      // Encode as surrogate pair
+      const hi = Math.floor((cp - 0x10000) / 0x400) + 0xD800;
+      const lo = ((cp - 0x10000) % 0x400) + 0xDC00;
+      return `\\u${hi.toString(16).toUpperCase().padStart(4, '0')}\\u${lo.toString(16).toUpperCase().padStart(4, '0')}`;
+    }
+    return `\\u${cp.toString(16).toUpperCase().padStart(4, '0')}`;
+  });
+}
+
+function generateProxy(appName) {
+  const appDir    = path.join(APPS_DIR, appName);
+  const paramFile = path.join(appDir, 'parameters.json');
+  const params    = fs.existsSync(paramFile) ? JSON.parse(fs.readFileSync(paramFile, 'utf8')) : {};
+
+  const proxy  = {}; // filename → transformed content
+  const assets = {}; // filename → { type, absPath }
+
+  for (const file of fs.readdirSync(appDir)) {
+    if (!TAB_MAP[file]) continue;
+
+    const filePath = path.join(appDir, file);
+    let content    = fs.readFileSync(filePath, 'utf8');
+    const ext      = path.extname(file).slice(1).toLowerCase();
+    const isJS     = ext === 'js';
+    const isCSS    = ext === 'css';
+    const isHTML   = ext === 'html';
+
+    if (isJS || isCSS) {
+      // 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*)(?:"[^"]*"|'[^']*')`, 'g');
+          content = content.replace(re, `$1"{parameter:${key}}"`);
+        }
+      }
+
+      // 2. Asset path substitution: "...assets/file.ext" → "{resources:type/file.ext}"
+      const assetInStringRe = /(['"])(?:\.\.\/)*assets\/([^'"]+)\1/g;
+      content = content.replace(assetInStringRe, (match, quote, assetFile) => {
+        const assetExt  = path.extname(assetFile).slice(1).toLowerCase();
+        const type      = assetResourceType(assetExt);
+        const absPath   = path.join(ASSETS_DIR, assetFile);
+        if (fs.existsSync(absPath)) assets[assetFile] = { type, absPath };
+        return `"{resources:${type}/${assetFile}}"`;
+      });
+
+      // CSS url() pattern
+      if (isCSS) {
+        const assetUrlRe = /url\((['"]?)(?:\.\.\/)*assets\/([^'")\s]+)\1\)/g;
+        content = content.replace(assetUrlRe, (match, quote, assetFile) => {
+          const assetExt = path.extname(assetFile).slice(1).toLowerCase();
+          const type     = assetResourceType(assetExt);
+          const absPath  = path.join(ASSETS_DIR, assetFile);
+          if (fs.existsSync(absPath)) assets[assetFile] = { type, absPath };
+          return `url("{resources:${type}/${assetFile}}")`;
+        });
+      }
+
+      // 3. Emoji → unicode escapes (JS only)
+      if (isJS) content = escapeEmojiInJS(content);
+    }
+
+    if (isHTML) {
+      // Strip local <link> tags (keep CDN ones with https://)
+      content = content.replace(/<link\b[^>]*\bhref=["'](?!https?:\/\/)[^"']*["'][^>]*\/?>/gi, '');
+      // Strip local <script src> tags (keep CDN ones)
+      content = content.replace(/<script\b[^>]*\bsrc=["'](?!https?:\/\/)[^"']*["'][^>]*>\s*<\/script>/gi, '');
+    }
+
+    proxy[file] = content;
+  }
+
+  return { proxy, assets, params };
+}
+
+// ─── Clipboard ────────────────────────────────────────────────────────────────
+
+function writeClipboard(text) {
+  const { platform } = process;
+  let attempts;
+
+  if (platform === 'darwin') {
+    attempts = [
+      () => spawnSync('pbcopy', [], { input: text, encoding: 'utf8' }),
+    ];
+  } else if (platform === 'win32') {
+    attempts = [
+      () => spawnSync('powershell', ['-noprofile', '-command', 'Set-Clipboard -Value $input'], { input: text, encoding: 'utf8' }),
+      () => spawnSync('clip', [], { input: text, encoding: 'utf8' }),
+    ];
+  } else {
+    // Linux / other Unix
+    attempts = [
+      () => spawnSync('wl-copy', [], { input: text, encoding: 'utf8' }),
+      () => spawnSync('xclip', ['-selection', 'clipboard'], { input: text, encoding: 'utf8' }),
+      () => spawnSync('xsel', ['--clipboard', '--input'], { input: text, encoding: 'utf8' }),
+    ];
+  }
+
+  for (const attempt of attempts) {
+    if (attempt().status === 0) return;
+  }
+  throw new Error(`No clipboard utility found for platform: ${platform}`);
+}
+
+// ─── Puppeteer Helpers ────────────────────────────────────────────────────────
+
+/** Click an element found by its exact visible text. Throws if not found. */
+async function clickByText(page, text, tag) {
+  const pos = await page.evaluate((text, tag) => {
+    const els = Array.from(document.querySelectorAll(tag || '*'));
+    const el  = els.find(e => {
+      const r = e.getBoundingClientRect();
+      return r.width > 0 && r.height > 0 && e.textContent.trim() === text;
+    });
+    if (!el) return null;
+    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) };
+  }, text, tag || null);
+  if (!pos) throw new Error(`Element not found: "${text}"${tag ? ` (tag: ${tag})` : ''}`);
+  await page.mouse.click(pos.x, pos.y);
+}
+
+/** Like clickByText but returns false instead of throwing when not found. */
+async function clickByTextSoft(page, text, tag) {
+  const pos = await page.evaluate((text, tag) => {
+    const els = Array.from(document.querySelectorAll(tag || '*'));
+    const el  = els.find(e => {
+      const r = e.getBoundingClientRect();
+      return r.width > 0 && r.height > 0 && e.textContent.trim() === text;
+    });
+    if (!el) return null;
+    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) };
+  }, text, tag || null);
+  if (!pos) return false;
+  await page.mouse.click(pos.x, pos.y);
+  return true;
+}
+
+/** Type into a field: click it, Ctrl+A, Delete, then type. */
+async function typeInField(page, selector, value) {
+  const input = await page.$(selector);
+  if (!input) throw new Error(`Input not found: ${selector}`);
+  const rect = 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) };
+  }, input);
+  await page.mouse.click(rect.x, rect.y);
+  await page.keyboard.down('Control');
+  await page.keyboard.press('a');
+  await page.keyboard.up('Control');
+  await page.keyboard.press('Delete');
+  await page.keyboard.type(value, { delay: 30 });
+}
+
+/** Type in search input and optionally click a "Go" button. */
+async function searchFor(page, name) {
+  const searchInput = await page.$('#searchInput, input[type="search"], input[placeholder*="earch" i]');
+  if (!searchInput) throw new Error('Search input not found');
+  const rect = 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) };
+  }, searchInput);
+  await page.mouse.click(rect.x, rect.y);
+  await page.keyboard.down('Control');
+  await page.keyboard.press('a');
+  await page.keyboard.up('Control');
+  await page.keyboard.type(name, { delay: 40 });
+  await sleep(400);
+  // Click Go if present (Uboxes page has it; apps page may filter automatically)
+  await clickByTextSoft(page, 'Go', 'button');
+  await sleep(2000);
+}
+
+/** Upload a file via CDP, bypassing the OS file dialog. */
+async function uploadFile(page, absPath) {
+  const client = await page.createCDPSession();
+  await client.send('DOM.getDocument');
+  const result = await client.send('DOM.querySelector', {
+    nodeId: 1,
+    selector: 'input[type="file"].fileIn, input[type="file"]',
+  });
+  if (!result.nodeId) throw new Error('File input not found');
+  const { node } = await client.send('DOM.describeNode', { nodeId: result.nodeId });
+  await client.send('DOM.setFileInputFiles', {
+    backendNodeId: node.backendNodeId,
+    files: [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; }
+    }
+    return false;
+  }, content);
+  if (monacoOk) return;
+
+  // Try CodeMirror API
+  const cmOk = await page.evaluate(text => {
+    const cm = document.querySelector('.CodeMirror');
+    if (cm?.CodeMirror) { cm.CodeMirror.setValue(text); return true; }
+    return false;
+  }, content);
+  if (cmOk) return;
+
+  // Fallback: clipboard paste into Ace / generic textarea
+  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);
+  await sleep(200);
+  await page.keyboard.down('Control');
+  await page.keyboard.press('a');
+  await page.keyboard.up('Control');
+  await sleep(100);
+  await page.keyboard.down('Control');
+  await page.keyboard.press('v');
+  await page.keyboard.up('Control');
+  await sleep(800);
+}
+
+// ─── Phase 1: Login ───────────────────────────────────────────────────────────
+
+async function login(page, email, password) {
+  console.log('[login] Navigating to studio.ubox.world...');
+  await page.goto(`${BASE_URL}/`, { waitUntil: 'networkidle2' });
+
+  if (!page.url().includes('#/login')) {
+    console.log('[login] Already logged in, skipping');
+    return;
+  }
+
+  console.log('[login] Filling credentials...');
+  await typeInField(page, 'input[type="email"], input[placeholder="Email"]', email);
+  await typeInField(page, 'input[type="password"], input[placeholder="Password"]', password);
+  await clickByText(page, 'Sign in', 'button');
+  await page.waitForFunction(() => !location.href.includes('#/login'), { timeout: 20000 });
+  console.log('[login] Logged in');
+}
+
+// ─── Phase 2: Application Deployment ─────────────────────────────────────────
+
+async function findOrCreateApp(page, fullName) {
+  console.log(`  [app] Searching for "${fullName}"...`);
+  await page.goto(`${BASE_URL}/#/apps`, { waitUntil: 'networkidle2' });
+  await sleep(1500);
+  await searchFor(page, fullName);
+
+  // Scan all app card links and match by card title text.
+  // The link <a href="#/application/XXX"> wraps the card image (outside card-body),
+  // so closest('[class*="card"]') on the title <p> would stop at card-body and miss it.
+  // Instead, iterate links directly and check their parent .card for the title.
+  const appHref = await page.evaluate(name => {
+    for (const link of document.querySelectorAll('a[href*="#/application/"]')) {
+      const card = link.closest('.card');
+      if (!card) continue;
+      const title = card.querySelector('p.card-text');
+      if (title && title.textContent.trim() === name) return link.href;
+    }
+    return null;
+  }, fullName);
+
+  if (appHref) {
+    console.log(`  [app] Found: ${appHref}`);
+    await page.goto(appHref, { waitUntil: 'networkidle2' });
+    await sleep(2000);
+    return appHref;
+  }
+
+  // Create new application
+  console.log(`  [app] Not found. Creating "${fullName}"...`);
+  await clickByText(page, 'New application', 'button');
+  await sleep(1200);
+
+  // Fill the name field in the modal
+  const nameInput = await page.$('#create-application-form input[type="text"], #create-application-form input[name="name"]');
+  if (!nameInput) throw new Error('App creation modal: name input not found');
+  await nameInput.click({ clickCount: 3 });
+  await page.keyboard.type(fullName, { delay: 30 });
+  await sleep(400);
+
+  await clickByText(page, 'Create', 'button');
+  await sleep(3000);
+
+  const newUrl = page.url();
+  console.log(`  [app] Created: ${newUrl}`);
+  return newUrl;
+}
+
+async function uploadResources(page, assets) {
+  if (Object.keys(assets).length === 0) {
+    console.log('  [resources] No assets');
+    return;
+  }
+
+  console.log(`  [resources] Uploading ${Object.keys(assets).length} asset(s)...`);
+  await clickByText(page, 'Resources');
+  await sleep(1500);
+
+  // Group assets by sub-tab
+  const byTab = {};
+  for (const [filename, info] of Object.entries(assets)) {
+    const label = info.type === 'images' ? 'Images' : info.type === 'fonts' ? 'Fonts' : 'Files';
+    if (!byTab[label]) byTab[label] = [];
+    byTab[label].push({ filename, ...info });
+  }
+
+  for (const [tabLabel, files] of Object.entries(byTab)) {
+    await clickByText(page, tabLabel);
+    await sleep(1000);
+
+    for (const { filename, absPath } of files) {
+      // Delete existing file with same name before uploading (avoid duplicates).
+      // Resource cards have <h5 class="card-title dcartitle" title="01.jpg">01.jpg</h5>
+      // with a <button class="btn btn-danger btn-sm"> delete button inside the same card.
+      const existingDeletePos = await page.evaluate(name => {
+        const h5 = Array.from(document.querySelectorAll('h5.dcartitle, h5.card-title'))
+          .find(el => el.getAttribute('title') === name || el.textContent.trim() === name);
+        if (!h5) return null;
+        const card = h5.closest('.card') || h5.parentElement;
+        if (!card) return null;
+        const deleteBtn = card.querySelector('.btn-danger, button.btn-danger');
+        if (!deleteBtn) return null;
+        deleteBtn.scrollIntoView({ block: 'nearest' });
+        const r = deleteBtn.getBoundingClientRect();
+        return { x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
+      }, filename);
+
+      if (existingDeletePos) {
+        console.log(`    ${filename} — deleting existing file first`);
+        page.once('dialog', d => d.accept());
+        await page.mouse.click(existingDeletePos.x, existingDeletePos.y);
+        await sleep(2000);
+      }
+
+      console.log(`    ${filename} → ${tabLabel}`);
+      await uploadFile(page, absPath);
+      await sleep(3000);
+    }
+  }
+}
+
+async function configureParameters(page, params) {
+  const entries = Object.entries(params);
+  if (entries.length === 0) {
+    console.log('  [params] No parameters');
+    return;
+  }
+
+  console.log(`  [params] Configuring ${entries.length} parameter(s)...`);
+  await clickByText(page, 'Parameters');
+  await sleep(1500);
+
+  // Check which parameters already exist in the read-only table.
+  // The read-only view has <th scope="row">key</th> for each parameter row.
+  const existingKeys = await page.evaluate(() => {
+    return Array.from(document.querySelectorAll('table tbody th[scope="row"]'))
+      .map(th => th.textContent.trim());
+  });
+
+  const toCreate = entries.filter(([key]) => !existingKeys.includes(key));
+
+  if (toCreate.length === 0) {
+    console.log('  [params] All parameters already exist, skipping');
+    return;
+  }
+
+  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);
+
+  for (const [key, def] of toCreate) {
+    const added = await clickByTextSoft(page, 'Add One', 'button') ||
+                  await clickByTextSoft(page, 'Add one', 'button');
+    if (!added) throw new Error('Could not find "Add One" button in Parameters');
+    await sleep(800);
+
+    // Find the empty row and fill fields left-to-right: KEY, DESCRIPTION, VALUE, DEFAULT VALUE
+    const fieldRects = await page.evaluate(() => {
+      const rows = Array.from(document.querySelectorAll('table tr'));
+      for (const row of rows) {
+        const inputs = Array.from(row.querySelectorAll('input, textarea'))
+          .filter(e => { const r = e.getBoundingClientRect(); return r.width > 0 && r.height > 0; });
+        if (inputs.length < 1) continue;
+        if (inputs[0].value.trim() === '') {
+          return inputs.slice(0, 4).map(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 (!fieldRects) throw new Error(`Could not find empty parameter row for key: "${key}"`);
+
+    const values = [
+      key,
+      def.description    || '',
+      def.value          || key,
+      def['default value'] || key,
+    ];
+
+    for (let i = 0; i < Math.min(fieldRects.length, values.length); i++) {
+      await page.mouse.click(fieldRects[i].x, fieldRects[i].y);
+      await page.keyboard.down('Control');
+      await page.keyboard.press('a');
+      await page.keyboard.up('Control');
+      await page.keyboard.press('Delete');
+      await page.keyboard.type(values[i], { delay: 20 });
+      await sleep(100);
+    }
+  }
+
+  await clickByText(page, 'Save', 'button');
+  await sleep(1500);
+}
+
+async function injectSource(page, proxy) {
+  console.log('  [source] Injecting source files...');
+  await clickByText(page, 'Source');
+  await sleep(1500);
+
+  await clickByText(page, 'Edit source');
+  await sleep(3000);
+
+  // Tab label → filename
+  const tabs = [
+    ['HTML',           'index.html' ],
+    ['CSS',            'style.css'  ],
+    ['Ubox Events',    'ubox.js'    ],
+    ['Workflow',       'workflow.js'],
+    ['Business logic', 'logic.js'  ],
+    ['Data source',    'data.js'   ],
+  ];
+
+  for (const [tabLabel, filename] of tabs) {
+    if (!proxy[filename]) continue;
+    console.log(`    ${filename} → ${tabLabel}`);
+    await clickByText(page, tabLabel);
+    await sleep(1000);
+    await injectToEditor(page, proxy[filename]);
+    await sleep(500);
+  }
+
+  await clickByText(page, 'Save and back to app');
+  await sleep(3000);
+}
+
+async function deployApp(page, appName, projectName, { noAssets = false } = {}) {
+  const fullName         = `${projectName} ${appName}`;
+  const { proxy, assets, params } = generateProxy(appName);
+
+  console.log(`\n[Phase 2] App: ${fullName}`);
+  console.log(`  Files: ${Object.keys(proxy).length}, Assets: ${Object.keys(assets).length}, Params: ${Object.keys(params).length}`);
+
+  await findOrCreateApp(page, fullName);
+  if (noAssets) {
+    console.log('  [resources] Skipped (--noassets)');
+  } else {
+    await uploadResources(page, assets);
+  }
+  await configureParameters(page, params);
+  await injectSource(page, proxy);
+
+  // Extract app ID from current URL
+  const appId = page.url().match(/#\/application(?:-source)?\/(\d+)/)?.[1] || '?';
+  console.log(`  [app] Done — ID: ${appId}`);
+  return appId;
+}
+
+// ─── Phase 3: Ubox Deployment ─────────────────────────────────────────────────
+
+async function handleTCModal(page) {
+  console.log('  [ubox] Handling Terms & Conditions modal...');
+  // Scroll all overflow elements to bottom to reveal the checkbox
+  await page.evaluate(() => {
+    Array.from(document.querySelectorAll('*')).forEach(e => {
+      const s = window.getComputedStyle(e);
+      if ((s.overflowY === 'auto' || s.overflowY === 'scroll') && e.scrollHeight > e.clientHeight) {
+        e.scrollTop = e.scrollHeight;
+      }
+    });
+  });
+  await sleep(800);
+
+  // Check the checkbox
+  await page.evaluate(() => {
+    const cb = Array.from(document.querySelectorAll('input[type="checkbox"]'))
+      .find(e => { const r = e.getBoundingClientRect(); return r.width > 0 && r.height > 0; });
+    if (cb && !cb.checked) cb.click();
+  });
+  await sleep(400);
+
+  await clickByText(page, 'Accept', 'button');
+  await sleep(1500);
+}
+
+async function findOrCreateUbox(page, fullName) {
+  console.log(`  [ubox] Searching for "${fullName}"...`);
+  await page.goto(`${BASE_URL}/#/uboxes`, { waitUntil: 'networkidle2' });
+  await sleep(1500);
+  await searchFor(page, fullName);
+
+  // Same pattern as apps: link is outside card-body, so scan links directly.
+  const uboxHref = await page.evaluate(name => {
+    for (const link of document.querySelectorAll('a[href*="#/ubox/"]')) {
+      // Exclude nav links like "#/uboxes" — only match "#/ubox/NNN"
+      if (!/\/#\/ubox\/\d+$/.test(link.href)) continue;
+      const card = link.closest('.card');
+      if (!card) continue;
+      const title = card.querySelector('p.card-text');
+      if (title && title.textContent.trim() === name) return link.href;
+    }
+    return null;
+  }, fullName);
+
+  if (uboxHref) {
+    console.log(`  [ubox] Found: ${uboxHref}`);
+    await page.goto(uboxHref, { waitUntil: 'networkidle2' });
+    await sleep(2000);
+    return { url: uboxHref, created: false };
+  }
+
+  // Create new Ubox
+  console.log(`  [ubox] Not found. Creating "${fullName}"...`);
+  await clickByText(page, 'New Ubox', 'button');
+  await sleep(1500);
+
+  // Check if T&C modal is showing (has "Accept" button)
+  const hasTCModal = await page.evaluate(() => {
+    return Array.from(document.querySelectorAll('button'))
+      .some(b => { const r = b.getBoundingClientRect(); return r.width > 0 && r.height > 0 && b.textContent.trim() === 'Accept'; });
+  });
+  if (hasTCModal) await handleTCModal(page);
+
+  // Fill Ubox form
+  const nameInput = await page.$('#ubox-form input[name="name"], #ubox-form input[placeholder*="name" i], .modal input[type="text"]');
+  if (!nameInput) throw new Error('Ubox creation modal: name input not found');
+  await nameInput.click({ clickCount: 3 });
+  await page.keyboard.type(fullName, { delay: 30 });
+  await sleep(300);
+
+  // Place select: find 1st visible select, choose "Claude"
+  await page.evaluate(() => {
+    const sels = Array.from(document.querySelectorAll('select'))
+      .filter(e => { const r = e.getBoundingClientRect(); return r.width > 0 && r.height > 0; });
+    if (sels[0]) {
+      const opt = Array.from(sels[0].options).find(o => /Claude/i.test(o.text));
+      if (opt) { sels[0].value = opt.value; sels[0].dispatchEvent(new Event('change', { bubbles: true })); }
+    }
+  });
+  await sleep(300);
+
+  // Config select: find 2nd visible select, choose "MyUboxConf"
+  await page.evaluate(() => {
+    const sels = Array.from(document.querySelectorAll('select'))
+      .filter(e => { const r = e.getBoundingClientRect(); return r.width > 0 && r.height > 0; });
+    if (sels[1]) {
+      const opt = Array.from(sels[1].options).find(o => /MyUboxConf/i.test(o.text));
+      if (opt) { sels[1].value = opt.value; sels[1].dispatchEvent(new Event('change', { bubbles: true })); }
+    }
+  });
+  await sleep(300);
+
+  await clickByText(page, 'Create', 'button');
+  await sleep(3000);
+
+  const newUrl = page.url();
+  console.log(`  [ubox] Created: ${newUrl}`);
+  return { url: newUrl, created: true };
+}
+
+async function installApp(page, appFullName) {
+  console.log(`  [ubox] Installing "${appFullName}"...`);
+
+  // Click "Available applications" tab
+  const tabPos = await page.evaluate(() => {
+    const tab = Array.from(document.querySelectorAll('a, li')).find(e => {
+      const r = e.getBoundingClientRect();
+      return r.width > 0 && r.height > 0 && e.textContent.trim() === 'Available applications';
+    });
+    if (!tab) return null;
+    tab.scrollIntoView({ block: 'nearest' });
+    const r = tab.getBoundingClientRect();
+    return { x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
+  });
+  if (!tabPos) throw new Error('"Available applications" tab not found');
+  await page.mouse.click(tabPos.x, tabPos.y);
+  await sleep(1500);
+
+  await searchFor(page, appFullName);
+
+  // Find the Install <a> element. After search only one card is visible.
+  // The button has class "uboxBot" per the platform HTML; its textContent
+  // includes a Font Awesome icon character before "Install" so we match by
+  // class or by text ending with "Install" rather than exact equality.
+  const installPos = await page.evaluate(() => {
+    const el = document.querySelector('a.uboxBot') ||
+      Array.from(document.querySelectorAll('a')).find(e => {
+        const r = e.getBoundingClientRect();
+        return r.width > 0 && r.height > 0 && e.textContent.trim().endsWith('Install');
+      });
+    if (!el) return null;
+    el.scrollIntoView({ block: 'center' });
+    const r = el.getBoundingClientRect();
+    return { x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
+  });
+
+  if (!installPos) throw new Error(`Install button for "${appFullName}" not found`);
+  await page.mouse.click(installPos.x, installPos.y);
+  await sleep(2500);
+  console.log('  [ubox] Installed');
+}
+
+async function checkMakePublic(page) {
+  // The checkbox is <input id="flexCheckChecked"> — a sibling of its label,
+  // both inside a .form-check div in the page header.
+  // Angular requires page.mouse.click(), NOT element.click() from evaluate().
+  const cbPos = await page.evaluate(() => {
+    // Primary: known ID from the DOM snapshot
+    const cb = document.querySelector('#flexCheckChecked') ||
+      Array.from(document.querySelectorAll('input[type="checkbox"]')).find(c => {
+        const r = c.getBoundingClientRect();
+        return r.width > 0 && r.height > 0;
+      });
+    if (!cb) return null;
+    if (cb.checked) return 'already';
+    cb.scrollIntoView({ block: 'nearest' });
+    const r = cb.getBoundingClientRect();
+    return { x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
+  });
+
+  if (cbPos === null)      { console.warn('  [ubox] WARNING: "make public" checkbox not found'); return; }
+  if (cbPos === 'already') { console.log('  [ubox] "make public" already checked'); return; }
+
+  await page.mouse.click(cbPos.x, cbPos.y);
+  await sleep(600);
+  console.log('  [ubox] Checked "make public"');
+}
+
+async function getVirtualLink(page) {
+  // Click "Open Virtual Ubox Link" — it opens a new tab; capture that tab's URL.
+  const browser = page.browser();
+
+  const newPagePromise = new Promise(resolve => {
+    browser.once('targetcreated', async target => {
+      const newPage = await target.page();
+      resolve(newPage);
+    });
+  });
+
+  // Button has an <i> icon child so textContent is e.g. " Open Virtual Ubox Link".
+  // Use includes() and page.mouse.click() (Angular SPA rule).
+  const btnPos = await page.evaluate(() => {
+    const btn = Array.from(document.querySelectorAll('button')).find(e => {
+      const r = e.getBoundingClientRect();
+      return r.width > 0 && r.height > 0 && e.textContent.includes('Open Virtual Ubox Link');
+    });
+    if (!btn) return null;
+    btn.scrollIntoView({ block: 'nearest' });
+    const r = btn.getBoundingClientRect();
+    return { x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
+  });
+  if (!btnPos) {
+    console.warn('  [ubox] WARNING: "Open Virtual Ubox Link" button not found');
+    return null;
+  }
+  await page.mouse.click(btnPos.x, btnPos.y);
+
+  const newPage = await Promise.race([
+    newPagePromise,
+    sleep(8000).then(() => null),
+  ]);
+  if (!newPage) {
+    console.warn('  [ubox] WARNING: New tab did not open');
+    return null;
+  }
+
+  // Wait for the virtual player page to fully load
+  await newPage.waitForNavigation({ waitUntil: 'networkidle2', timeout: 15000 }).catch(() => {});
+  await sleep(1000);
+  const virtualLink = newPage.url();
+  await newPage.close();
+  return virtualLink;
+}
+
+async function setMobileLink(page, appFullName, mobileVirtualLink) {
+  console.log(`  [ubox] Setting mobileLink param for "${appFullName}"...`);
+
+  // Click "Installed applications" tab — search only <a> tags to avoid
+  // accidentally matching <li> wrappers with combined child text
+  const tabPos = await page.evaluate(() => {
+    const tab = Array.from(document.querySelectorAll('a')).find(e => {
+      const r = e.getBoundingClientRect();
+      return r.width > 0 && r.height > 0 && /^\s*Installed applications\s*$/.test(e.textContent);
+    });
+    if (!tab) return null;
+    tab.scrollIntoView({ block: 'nearest' });
+    const r = tab.getBoundingClientRect();
+    return { x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
+  });
+  if (!tabPos) throw new Error('"Installed applications" tab not found');
+  await page.mouse.click(tabPos.x, tabPos.y);
+  await sleep(1500);
+
+  // Find "Change params" button directly — the page header has an <h1> with the same
+  // app name so searching by title text is unreliable. Use the known uboxBot class
+  // (same class the Install button uses) combined with btn-outline-info.
+  const changeParamsPos = await page.evaluate(() => {
+    const btn = document.querySelector('a.uboxBot.btn-outline-info') ||
+      Array.from(document.querySelectorAll('a, button')).find(e => {
+        const r = e.getBoundingClientRect();
+        return r.width > 0 && r.height > 0 && e.textContent.includes('Change params');
+      });
+    if (!btn) return null;
+    btn.scrollIntoView({ block: 'center' });
+    const r = btn.getBoundingClientRect();
+    return { x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
+  });
+
+  if (!changeParamsPos) throw new Error(`"Change params" button not found`);
+  await page.mouse.click(changeParamsPos.x, changeParamsPos.y);
+
+  // Wait for the modal to open and the API to populate the params table rows
+  await page.waitForFunction(() => {
+    const modal = document.querySelector('#change-params-modal');
+    if (!modal) return false;
+    // Bootstrap adds "show" class when visible; params are loaded when tbody has tds
+    return modal.classList.contains('show') && modal.querySelectorAll('td').length > 0;
+  }, { timeout: 12000 }).catch(() => {});
+  await sleep(400);
+
+  // Find the value cell (column index 1) for the "mobileLink" key row
+  const valueInputPos = await page.evaluate(() => {
+    const modal = document.querySelector('#change-params-modal');
+    if (!modal) return null;
+    for (const row of modal.querySelectorAll('tr')) {
+      const cells = row.querySelectorAll('td');
+      if (cells[0]?.textContent.trim() === 'mobileLink') {
+        const input = cells[1]?.querySelector('input, textarea');
+        if (!input) return null;
+        input.scrollIntoView({ block: 'nearest' });
+        const r = input.getBoundingClientRect();
+        return { x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
+      }
+    }
+    return null;
+  });
+
+  if (!valueInputPos) throw new Error('mobileLink value input not found in params modal');
+  await page.mouse.click(valueInputPos.x, valueInputPos.y);
+  await page.keyboard.down('Control');
+  await page.keyboard.press('a');
+  await page.keyboard.up('Control');
+  await page.keyboard.press('Delete');
+  await page.keyboard.type(mobileVirtualLink, { delay: 20 });
+  await sleep(300);
+
+  await clickByText(page, 'Save', 'button');
+  await sleep(1500);
+  console.log(`  [ubox] mobileLink = ${mobileVirtualLink}`);
+}
+
+async function deployUbox(page, appName, projectName, appParams, mobileVirtualLink) {
+  const fullName = `${projectName} ${appName}`;
+  console.log(`\n[Phase 3] Ubox: ${fullName}`);
+
+  const { url: uboxUrl, created } = await findOrCreateUbox(page, fullName);
+
+  let virtualLink = null;
+
+  if (created) {
+    // Fresh ubox — need to make public, install app, get virtual link, set params
+    await checkMakePublic(page);
+    await installApp(page, fullName);
+
+    if (appName === 'mobile') {
+      await sleep(500);
+      virtualLink = await getVirtualLink(page);
+      if (virtualLink) {
+        console.log(`  [ubox] Mobile Virtual Link: ${virtualLink}`);
+      } else {
+        console.warn('  [ubox] WARNING: Could not retrieve Mobile Virtual Link');
+      }
+    }
+
+    if (appParams.mobileLink !== undefined && mobileVirtualLink) {
+      await setMobileLink(page, fullName, mobileVirtualLink);
+    }
+  } else {
+    // Existing ubox — skip install, params, and virtual link retrieval
+    console.log('  [ubox] Already exists — skipping install, params, and virtual link');
+
+    // Still retrieve the virtual link for mobile so main can use it
+    if (appName === 'mobile') {
+      virtualLink = await getVirtualLink(page);
+      if (virtualLink) {
+        console.log(`  [ubox] Mobile Virtual Link: ${virtualLink}`);
+      }
+    }
+  }
+
+  const uboxId = page.url().match(/#\/ubox\/(\d+)/)?.[1] ||
+                 uboxUrl.match(/#\/ubox\/(\d+)/)?.[1] || '?';
+  return { uboxId, virtualLink };
+}
+
+// ─── Main ─────────────────────────────────────────────────────────────────────
+
+async function main() {
+  const { apps, email: emailArg, password: passwordArg, projectName: projectNameArg, noAssets, noPlayer, show } = parseArgs();
+
+  if (apps.length === 0) {
+    console.error('No apps found in apps/ directory. Nothing to deploy.');
+    process.exit(1);
+  }
+
+  const projectName = projectNameArg || PROJECT_NAME;
+
+  console.log(`Project : ${projectName}`);
+  console.log(`Apps    : ${apps.join(', ')}`);
+  if (noAssets) console.log('Flags   : --noassets (skip resource uploads)');
+  if (noPlayer) console.log('Flags   : --noplayer (skip Ubox creation)');
+  console.log('');
+
+  const { email, password } = await promptCredentials(emailArg, passwordArg);
+
+  const browser = await puppeteer.launch({
+    headless: !show,
+    defaultViewport: null,
+    args: ['--start-maximized'],
+  });
+
+  const pages = await browser.pages();
+  const page  = pages[0] ?? await browser.newPage();
+  page.setDefaultTimeout(20000);
+
+  const state = {};
+
+  try {
+    // Phase 1 — Login
+    await login(page, email, password);
+
+    // Phase 2 — Deploy apps (also collect params for Phase 3)
+    const appParamsMap = {};
+    for (const appName of apps) {
+      state[appName] = {};
+      const { params } = generateProxy(appName);
+      appParamsMap[appName] = params;
+      state[appName].appId = await deployApp(page, appName, projectName, { noAssets });
+    }
+
+    // Phase 3 — Deploy Uboxes
+    if (noPlayer) {
+      console.log('\n[Phase 3] Skipped (--noplayer)');
+    } else {
+      let mobileVirtualLink = null;
+      for (const appName of apps) {
+        const { uboxId, virtualLink } = await deployUbox(
+          page, appName, projectName, appParamsMap[appName], mobileVirtualLink
+        );
+        state[appName].uboxId = uboxId;
+        if (appName === 'mobile' && virtualLink) {
+          mobileVirtualLink = virtualLink;
+          state[appName].virtualLink = virtualLink;
+        }
+      }
+    }
+
+    // Summary
+    console.log('\n--- Deployment complete ---\n');
+    for (const appName of apps) {
+      const s = state[appName];
+      console.log(`  ${appName} app  → #/application/${s.appId}`);
+      if (s.uboxId) console.log(`  ${appName} Ubox → #/ubox/${s.uboxId}`);
+      if (s.virtualLink) console.log(`  Mobile Virtual Link: ${s.virtualLink}`);
+    }
+    console.log('');
+
+  } catch (err) {
+    console.error('\n[ERROR]', err.message);
+    const screenshotPath = path.join(PROJECT_ROOT, 'deploy_error.png');
+    await page.screenshot({ path: screenshotPath });
+    console.error(`Screenshot saved: ${screenshotPath}`);
+    process.exitCode = 1;
+  }
+
+  if (show) {
+    console.log('Browser left open for inspection. Press Ctrl+C to close.');
+    process.on('SIGINT', () => browser.close().then(() => process.exit()));
+    await new Promise(() => {});
+  } else {
+    await browser.close();
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@ubox-tools/deploy-xperience",
+  "version": "1.0.0",
+  "description": "Deploy a Ubox experience to studio.ubox.world",
+  "bin": { "deploy-xperience": "./deploy.js" },
+  "dependencies": { "puppeteer": "*" },
+  "engines": { "node": ">=18" }
+}