@microsoft/power-apps-native-host 0.2.22 → 0.2.25

package/scripts/build-ios-base.js

@@ -56,8 +56,13 @@ if (!xcworkspace) {
 // Derive scheme name from workspace name (strip .xcworkspace).
 const scheme = xcworkspace.replace('.xcworkspace', '');
 
-const archivePath = path.join(os.tmpdir(), 'pawrap-base.xcarchive');
-const ipaDir      = path.join(os.tmpdir(), 'pawrap-base-ipa');
+// --simulator: build for iOS Simulator instead of a physical device.
+// Use this for local testing; the default (device) build is for App Store / wrap pipeline.
+const isSimulator = process.argv.includes('--simulator');
+
+const archivePath    = path.join(os.tmpdir(), 'pawrap-base.xcarchive');
+const simDerivedPath = path.join(os.tmpdir(), 'pawrap-sim-derived');
+const ipaDir         = path.join(os.tmpdir(), 'pawrap-base-ipa');
 const payloadDir  = path.join(ipaDir, 'Payload');
 const ipaPath     = path.join(os.tmpdir(), 'pawrap-base.ipa');
 
@@ -66,31 +71,65 @@ function run(cmd, args, opts = {}) {
   execFileSync(cmd, args, { stdio: 'inherit', ...opts });
 }
 
-// 1. Archive (no code signing — wrap pipeline signs with customer cert).
-run('xcodebuild', [
-  '-workspace', path.join(iosDir, xcworkspace),
-  '-scheme',    scheme,
-  '-configuration', 'Release',
-  'archive',
-  '-archivePath', archivePath,
-  '-destination', 'generic/platform=iOS',
-  'CODE_SIGNING_REQUIRED=NO',
-  'CODE_SIGN_IDENTITY=',
-  'CODE_SIGNING_ALLOWED=NO',
-]);
-
-// 2. Package into an IPA.
-fs.rmSync(ipaDir, { recursive: true, force: true });
-fs.mkdirSync(payloadDir, { recursive: true });
-
-const appsGlob = path.join(archivePath, 'Products', 'Applications');
-for (const app of fs.readdirSync(appsGlob)) {
-  if (app.endsWith('.app')) {
-    fs.cpSync(path.join(appsGlob, app), path.join(payloadDir, app), { recursive: true });
+if (isSimulator) {
+  // ── Simulator build ──────────────────────────────────────────────────────
+  // Uses xcodebuild build (not archive) targeting iOS Simulator so the Mach-O
+  // platform is IOSSIMULATOR and xcrun simctl can launch it.
+  run('xcodebuild', [
+    '-workspace', path.join(iosDir, xcworkspace),
+    '-scheme',    scheme,
+    '-configuration', 'Release',
+    'build',
+    '-destination', 'generic/platform=iOS Simulator',
+    '-derivedDataPath', simDerivedPath,
+    'CODE_SIGNING_REQUIRED=NO',
+    'CODE_SIGN_IDENTITY=',
+    'CODE_SIGNING_ALLOWED=NO',
+  ]);
+
+  const simProductsDir = path.join(simDerivedPath, 'Build', 'Products', 'Release-iphonesimulator');
+  const appBundle = fs.readdirSync(simProductsDir).find(f => f.endsWith('.app'));
+  if (!appBundle) {
+    console.error('build-ios-base: no .app found in simulator build output');
+    process.exit(1);
   }
-}
 
-fs.rmSync(ipaPath, { force: true });
-run('zip', ['-r', ipaPath, '.'], { cwd: ipaDir });
+  // Package as IPA so the output format matches the device build.
+  // xcrun simctl install accepts simulator-built IPAs.
+  fs.rmSync(ipaDir, { recursive: true, force: true });
+  fs.mkdirSync(payloadDir, { recursive: true });
+  fs.cpSync(path.join(simProductsDir, appBundle), path.join(payloadDir, appBundle), { recursive: true });
+  fs.rmSync(ipaPath, { force: true });
+  run('zip', ['-r', ipaPath, '.'], { cwd: ipaDir });
+  console.log(`\n✓ Base IPA (simulator) ready: ${ipaPath}`);
+
+} else {
+  // ── Device build (default) ───────────────────────────────────────────────
+  // Archives without code signing so the wrap pipeline can re-sign with the
+  // customer's provisioning profile.
+  run('xcodebuild', [
+    '-workspace', path.join(iosDir, xcworkspace),
+    '-scheme',    scheme,
+    '-configuration', 'Release',
+    'archive',
+    '-archivePath', archivePath,
+    '-destination', 'generic/platform=iOS',
+    'CODE_SIGNING_REQUIRED=NO',
+    'CODE_SIGN_IDENTITY=',
+    'CODE_SIGNING_ALLOWED=NO',
+  ]);
 
-console.log(`\n✓ Base IPA ready: ${ipaPath}`);
+  fs.rmSync(ipaDir, { recursive: true, force: true });
+  fs.mkdirSync(payloadDir, { recursive: true });
+
+  const appsGlob = path.join(archivePath, 'Products', 'Applications');
+  for (const app of fs.readdirSync(appsGlob)) {
+    if (app.endsWith('.app')) {
+      fs.cpSync(path.join(appsGlob, app), path.join(payloadDir, app), { recursive: true });
+    }
+  }
+
+  fs.rmSync(ipaPath, { force: true });
+  run('zip', ['-r', ipaPath, '.'], { cwd: ipaDir });
+  console.log(`\n✓ Base IPA ready: ${ipaPath}`);
+}

package/scripts/bundle.js

@@ -1,27 +1,35 @@
 #!/usr/bin/env node
 /**
- * Cross-platform Metro → Hermes bundle script.
+ * Cross-platform Expo bundle script.
  *
  * Runs two steps:
  *   1. expo export:embed  — produces a plain Metro JS bundle
- *   2. hermesc            — compiles it to Hermes bytecode (.hbc)
+ *   2. hermesc            — compiles native bundles to Hermes bytecode (.hbc)
  *
  * Usage (via npm script in the consuming expo-app):
  *   bundle android   → dist/index.android.bundle.hbc
  *   bundle ios       → dist/main.jsbundle.hbc
+ *   bundle web       → dist-web/ (Code Apps static site)
+ *   bundle web powerpages → dist-web/ (Power Pages static site)
  *
  * Works on macOS, Linux, and Windows.
  */
 
 'use strict';
 
-const { execFileSync } = require('child_process');
+const { execFileSync, spawn } = require('child_process');
 const path = require('path');
 const fs   = require('fs');
 
 const platform = process.argv[2];
-if (platform !== 'android' && platform !== 'ios') {
-  console.error('Usage: bundle <android|ios>');
+if (platform !== 'android' && platform !== 'ios' && platform !== 'web') {
+  console.error('Usage: bundle <android|ios|web> [powerpages]');
+  process.exit(1);
+}
+
+const webTarget = process.argv[3] ?? 'codeapps';
+if (platform === 'web' && webTarget !== 'codeapps' && webTarget !== 'powerpages') {
+  console.error('Usage: bundle web [powerpages]');
   process.exit(1);
 }
 
@@ -32,6 +40,204 @@ const isLinux = process.platform === 'linux';
 const projectRoot   = process.cwd();
 const workspaceRoot = path.resolve(projectRoot, '../..');
 
+function validatePowerPagesDataSources() {
+  const configPath = path.join(projectRoot, 'power.config.json');
+  const powerConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  const unsupportedConnectors = Object.values(powerConfig.connectionReferences ?? {})
+    .filter((reference) => {
+      const connectorName = String(reference.id ?? '').split('/').pop()?.toLowerCase();
+      return connectorName !== 'shared_commondataserviceforapps';
+    })
+    .map((reference) => reference.displayName || reference.id || '<unknown>');
+
+  if (unsupportedConnectors.length > 0) {
+    throw new Error(
+      `Power Pages bundles support Dataverse only. Remove these connector references: ${unsupportedConnectors.join(', ')}`
+    );
+  }
+}
+
+function findFiles(directory, predicate) {
+  return fs.readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+    const entryPath = path.join(directory, entry.name);
+    return entry.isDirectory()
+      ? findFiles(entryPath, predicate)
+      : predicate(entryPath) ? [entryPath] : [];
+  });
+}
+
+function prepareHostedWebOutput(outputDir) {
+  const hostedFiles = findFiles(
+    outputDir,
+    (filePath) => /\.(?:html|js|css)$/.test(filePath),
+  );
+  for (const hostedFile of hostedFiles) {
+    const contents = fs.readFileSync(hostedFile, 'utf8');
+    const relativeAssetContents = contents.replace(
+      /(["'`])\/(assets|_expo)\//g,
+      '$1./$2/',
+    );
+    if (relativeAssetContents !== contents) {
+      fs.writeFileSync(hostedFile, relativeAssetContents);
+    }
+    if (/(["'`])\/(assets|_expo)\//.test(relativeAssetContents)) {
+      throw new Error(`Hosted web output contains a root-relative asset URL: ${hostedFile}`);
+    }
+  }
+}
+
+function prepareHostedSpaOutput(outputDir, isPowerPages) {
+  const entryBundles = findFiles(
+    outputDir,
+    (filePath) => /[/\\]_expo[/\\]static[/\\]js[/\\]web[/\\]entry-[^/\\]+\.js$/.test(filePath),
+  );
+  if (entryBundles.length !== 1) {
+    throw new Error(`Expected one hosted web entry bundle, found ${entryBundles.length}`);
+  }
+
+  const entryContents = fs.readFileSync(entryBundles[0], 'utf8');
+  const reactRuntimeCount = (entryContents.match(/react\.production\.js/g) ?? []).length;
+  if (reactRuntimeCount > 1) {
+    throw new Error(
+      `Hosted web bundle contains ${reactRuntimeCount} React runtimes. Configure Metro to resolve react and react/* from one node_modules path.`
+    );
+  }
+  const routerContextCount = (
+    entryContents.match(/No filename found\. This is likely a bug in expo-router\./g) ?? []
+  ).length;
+  if (routerContextCount > 1) {
+    throw new Error(
+      `Hosted web bundle contains ${routerContextCount} Expo Router contexts. Build from the canonical workspace path instead of a symlinked project root.`
+    );
+  }
+
+  const entryUrl = `/${path.relative(outputDir, entryBundles[0]).split(path.sep).join('/')}`;
+  const htmlFiles = findFiles(outputDir, (filePath) => filePath.endsWith('.html'));
+  for (const htmlFile of htmlFiles) {
+    fs.rmSync(htmlFile);
+  }
+
+  fs.writeFileSync(
+    path.join(outputDir, 'index.html'),
+    `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <style>#root,body,html{height:100%}body{margin:0;overflow:hidden}#root{display:flex}</style>
+  <script>
+    if (location.pathname.includes('/powerapps/appruntime/')) {
+      const assetBase = document.createElement('base');
+      assetBase.href = new URL('.', location.href).href;
+      document.head.appendChild(assetBase);
+      history.replaceState(history.state, '', '/' + location.search + location.hash);
+    }
+  </script>
+</head>
+<body>
+  <div id="root"></div>
+  <script src="${entryUrl}" defer></script>
+</body>
+</html>
+`,
+  );
+}
+
+function runExpoExport(expoBin, args, outputDir, env) {
+  const completionMarker = `Exported: ${outputDir}`;
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(expoBin, args, {
+      cwd: projectRoot,
+      env,
+      shell: isWin,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let outputTail = '';
+    let exportCompleted = false;
+
+    const forwardOutput = (chunk, destination) => {
+      destination.write(chunk);
+      outputTail = (outputTail + chunk).slice(-completionMarker.length * 2);
+      if (!exportCompleted && outputTail.includes(completionMarker)) {
+        exportCompleted = true;
+        if (isWin && child.pid) {
+          try {
+            execFileSync('taskkill', ['/pid', String(child.pid), '/t', '/f'], { stdio: 'ignore' });
+          } catch {
+            child.kill();
+          }
+        } else {
+          child.kill('SIGKILL');
+        }
+      }
+    };
+
+    child.stdout.on('data', (chunk) => forwardOutput(chunk, process.stdout));
+    child.stderr.on('data', (chunk) => forwardOutput(chunk, process.stderr));
+    child.once('error', reject);
+    child.once('exit', (code, signal) => {
+      if (exportCompleted) {
+        resolve();
+      } else {
+        reject(new Error(
+          code === 0
+            ? `Expo export exited before reporting completion: ${completionMarker}`
+            : `Expo export failed with ${signal ? `signal ${signal}` : `exit code ${code}`}`,
+        ));
+      }
+    });
+  });
+}
+
+async function bundleWeb() {
+  const isPowerPages = webTarget === 'powerpages';
+  if (isPowerPages) {
+    validatePowerPagesDataSources();
+  }
+
+  const outputDir = path.join(projectRoot, 'dist-web');
+  fs.rmSync(outputDir, { recursive: true, force: true });
+  console.log(`\n[bundle] Expo static export (${isPowerPages ? 'Power Pages' : 'Code Apps'})`);
+
+  const expoBinName = isWin ? 'expo.cmd' : 'expo';
+  const expoBinLocal = path.join(projectRoot, 'node_modules', '.bin', expoBinName);
+  const expoBinHoisted = path.join(workspaceRoot, 'node_modules', '.bin', expoBinName);
+  const expoBin = fs.existsSync(expoBinLocal) ? expoBinLocal : expoBinHoisted;
+
+  await runExpoExport(
+    expoBin,
+    ['export', '--platform', 'web', '--output-dir', outputDir, '--clear'],
+    outputDir,
+    {
+      ...process.env,
+      CI: process.env.CI ?? '1',
+      EXPO_NO_TELEMETRY: '1',
+    },
+  );
+
+  if (isPowerPages) {
+    prepareHostedSpaOutput(outputDir, true);
+  } else {
+    prepareHostedSpaOutput(outputDir, false);
+    prepareHostedWebOutput(outputDir);
+  }
+
+  console.log(`\n[bundle] Done. ${isPowerPages ? 'Power Pages' : 'Code Apps'} site: "${outputDir}"`);
+  process.exit(0);
+}
+
+if (platform === 'web') {
+  bundleWeb().catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+} else {
+  bundleNative();
+}
+
+function bundleNative() {
 const distDir = path.join(projectRoot, 'dist');
 fs.mkdirSync(distDir, { recursive: true });
 
@@ -93,3 +299,4 @@ const hermesc = fs.existsSync(path.join(hcDir, binDir, binName))
 execFileSync(hermesc, ['-emit-binary', '-out', outputFile, bundleFile], { stdio: 'inherit' });
 
 console.log(`\n[bundle] Done. Output: "${outputFile}"`);
+}

package/scripts/generate-connector-schemas.js

@@ -2,7 +2,8 @@
 /**
  * generate-connector-schemas
  *
- * Auto-generates src/connectorSchemas.ts by scanning .power/schemas/ for
+ * Customer-invoked generator for src/generated/connectorSchemas.ts. Scans
+ * .power/schemas/ for
  * connector schema JSON files placed there by `pac code add-data-source`.
  *
  * Run from the root of your Expo app (where .power/schemas/ lives):
@@ -11,9 +12,9 @@
  * Or wire it into package.json scripts:
  *   "prestart": "generate-connector-schemas"
  *
- * The generated file is re-created on every run and should be committed to
- * source control so TypeScript can resolve the connector schema types at
- * compile time.
+ * The generated file is customer-owned output: upgrade-template never changes
+ * it. Re-run this command after adding or removing connectors, and commit the
+ * result so TypeScript can resolve connector schema types at compile time.
  */
 
 'use strict';
@@ -47,8 +48,9 @@ if (fs.existsSync(schemasDir)) {
   console.warn('[generate-connector-schemas] .power/schemas/ not found — emitting empty schemaMap.');
 }
 
-const content = `// AUTO-GENERATED — do not edit manually.
-// Re-generated automatically on every \`npm run start\` / \`npm run build\`.
+const content = `// AUTO-GENERATED CUSTOMER FILE — do not edit manually.
+// Run \`npm run generate-schemas\` after adding or removing connectors.
+// This file is never modified by upgrade-template.
 // To add a connector: pac code add-data-source  (no further changes needed).
 // Generator: @microsoft/power-apps-native-host/scripts/generate-connector-schemas.js
 

package/scripts/start-web.mjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+
+const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+const npxCommand = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+const localAppUrl = 'http://localhost:8082';
+const children = new Set();
+let shuttingDown = false;
+
+async function readPowerConfig() {
+  const configPath = path.resolve(process.cwd(), 'power.config.json');
+  let config;
+  try {
+    config = JSON.parse(await readFile(configPath, 'utf8'));
+  } catch (error) {
+    throw new Error(
+      `Unable to read ${configPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+
+  if (typeof config.environmentId !== 'string' || !config.environmentId.trim()) {
+    throw new Error(`environmentId is required in ${configPath}`);
+  }
+  return config;
+}
+
+function run(command, args, options = {}) {
+  const child = spawn(command, args, {
+    cwd: process.cwd(),
+    env: process.env,
+    stdio: 'inherit',
+    ...options,
+  });
+  children.add(child);
+  child.once('exit', (code, signal) => {
+    children.delete(child);
+    if (!shuttingDown && (code !== 0 || signal)) {
+      shutdown(code ?? 1);
+    }
+  });
+  return child;
+}
+
+function shutdown(exitCode = 0) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  for (const child of children) {
+    child.kill('SIGTERM');
+  }
+  process.exitCode = exitCode;
+}
+
+async function waitForApp(timeoutMs = 60_000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(localAppUrl, {
+        headers: { Accept: 'text/html' },
+      });
+      if (response.ok) return;
+    } catch {
+      // Metro is still starting.
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  throw new Error(`Timed out waiting for ${localAppUrl}`);
+}
+
+function openBrowser(url) {
+  if (process.platform === 'darwin') {
+    spawn('open', [url], { detached: true, stdio: 'ignore' }).unref();
+  } else if (process.platform === 'win32') {
+    spawn('cmd.exe', ['/d', '/s', '/c', 'start', '', url], {
+      detached: true,
+      stdio: 'ignore',
+    }).unref();
+  } else {
+    spawn('xdg-open', [url], { detached: true, stdio: 'ignore' }).unref();
+  }
+}
+
+function captureLocalPlayUrl(child, environmentId) {
+  let output = '';
+  child.stdout.on('data', (chunk) => {
+    const text = chunk.toString();
+    process.stdout.write(text);
+    output += text;
+
+    const match = output.match(/https:\/\/[^\s]+_localAppUrl=[^\s]+/);
+    if (!match) return;
+
+    const playUrl = new URL(match[0]);
+    const environmentFromUrl = playUrl.pathname.match(/\/play\/e\/([^/]+)\//)?.[1];
+    if (decodeURIComponent(environmentFromUrl ?? '') !== environmentId) {
+      console.error(
+        `Local Play URL environment mismatch: expected ${environmentId}, received ${environmentFromUrl ?? 'none'}`
+      );
+      shutdown(1);
+      return;
+    }
+
+    child.stdout.removeAllListeners('data');
+    child.stdout.pipe(process.stdout);
+    void waitForApp()
+      .then(() => openBrowser(playUrl.href))
+      .catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        shutdown(1);
+      });
+  });
+}
+
+process.on('SIGINT', () => shutdown());
+process.on('SIGTERM', () => shutdown());
+
+const powerConfig = await readPowerConfig();
+console.log(`Starting Power Apps Local Play for environment ${powerConfig.environmentId}`);
+
+const schemaProcess = spawn(npmCommand, ['run', 'generate-schemas'], {
+  cwd: process.cwd(),
+  env: process.env,
+  stdio: 'inherit',
+});
+const schemaExitCode = await new Promise((resolve) => schemaProcess.once('exit', resolve));
+if (schemaExitCode !== 0) process.exit(schemaExitCode ?? 1);
+
+run(npxCommand, ['expo', 'start', '--port', '8082', '--localhost']);
+const powerApps = run(
+  npxCommand,
+  ['power-apps', 'run', '--port', '8080', '--local-app-url', localAppUrl],
+  { stdio: ['inherit', 'pipe', 'inherit'] }
+);
+captureLocalPlayUrl(powerApps, powerConfig.environmentId);