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

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/metro-logger.js

@@ -0,0 +1,213 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const SENSITIVE_LINE_PATTERN = /\b(?:authorization|bearer|client[_-]?secret|password|token|access[_-]?token|refresh[_-]?token|id[_-]?token|api[_-]?key|accountkey|sharedaccesskey)\b|[?&](?:sig|se|sp|sv|token|access_token|code|client_secret)=|\b(?:AKIA[0-9A-Z]{16}|ghp_[A-Za-z0-9]{30,}|sk-[A-Za-z0-9]{20,})\b/i;
+const DEFAULT_MAX_ERROR_BODY_BYTES = 256 * 1024;
+
+const stateByRoot = new Map();
+
+function stripAnsi(value) {
+  return String(value).replace(/[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d\/#&.:=?%@~_]+)*)?\u0007)|(?:(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g, '');
+}
+
+function redactMetroLog(value) {
+  return stripAnsi(value).replace(/[^\r\n]*(?:\r\n|\r|\n)|[^\r\n]+$/g, (line) => {
+    if (!SENSITIVE_LINE_PATTERN.test(line)) return line;
+    const ending = line.endsWith('\r\n') ? '\r\n' : line.endsWith('\n') ? '\n' : line.endsWith('\r') ? '\r' : '';
+    return `[powernative] [REDACTED_SENSITIVE_LINE]${ending}`;
+  });
+}
+
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+
+function writeDiagnostic(state, message) {
+  try {
+    state.diagnosticWrite(message);
+  } catch (error) {
+    state.diagnosticWriteError = toError(error);
+  }
+}
+
+function reportInstrumentationError(state, error, phase) {
+  if (state.instrumentationError) return;
+  const normalizedError = toError(error);
+  const context = { phase, logPath: state.logPath };
+  state.instrumentationError = { error: normalizedError, context };
+
+  if (typeof state.onError === 'function') {
+    try {
+      state.onError(normalizedError, context);
+      return;
+    } catch (callbackError) {
+      state.onErrorFailure = toError(callbackError);
+      writeDiagnostic(
+        state,
+        `[powernative] Metro logging instrumentation failed during ${phase}: ${normalizedError.message}; onError callback also failed: ${state.onErrorFailure.message}\n`,
+      );
+      return;
+    }
+  }
+
+  writeDiagnostic(
+    state,
+    `[powernative] Metro logging instrumentation failed during ${phase}: ${normalizedError.message}\n`,
+  );
+}
+
+function createMetroLogState(projectRoot, onError) {
+  const root = path.resolve(projectRoot || process.cwd());
+  const logDir = path.join(root, '.powernative', 'metro-logs');
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const stderrWrite = process.stderr.write.__powerNativeMetroLoggerOriginal || process.stderr.write;
+  const state = {
+    root,
+    logDir,
+    stamp,
+    port: 'unknown',
+    logPath: path.join(logDir, `metro-${stamp}-pid-${process.pid}-port-unknown.log`),
+    onError: typeof onError === 'function' ? onError : null,
+    instrumentationError: null,
+    diagnosticWrite: stderrWrite.bind(process.stderr),
+  };
+  stateByRoot.set(root, state);
+  return state;
+}
+
+function getMetroLogState(projectRoot, onError) {
+  const root = path.resolve(projectRoot || process.cwd());
+  const state = stateByRoot.get(root) || createMetroLogState(root, onError);
+  if (typeof onError === 'function') state.onError = onError;
+  return state;
+}
+
+function appendMetroLog(state, value) {
+  try {
+    fs.mkdirSync(state.logDir, { recursive: true });
+    fs.appendFileSync(state.logPath, redactMetroLog(value));
+  } catch (error) {
+    reportInstrumentationError(state, error, 'log persistence');
+  }
+}
+
+function setMetroLogPort(state, port) {
+  if (!Number.isInteger(port) || port <= 0 || String(port) === state.port) return;
+  const previousPath = state.logPath;
+  state.port = String(port);
+  state.logPath = path.join(state.logDir, `metro-${state.stamp}-pid-${process.pid}-port-${state.port}.log`);
+  try {
+    fs.mkdirSync(state.logDir, { recursive: true });
+    if (fs.existsSync(previousPath) && previousPath !== state.logPath) {
+      fs.renameSync(previousPath, state.logPath);
+    }
+  } catch (error) {
+    state.logPath = previousPath;
+    reportInstrumentationError(state, error, 'port-tagged log rename');
+  }
+}
+
+function extractMetroPort(value) {
+  const match = String(value).match(/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\]):(\d{2,5})/);
+  const port = match ? Number(match[1]) : null;
+  return Number.isInteger(port) && port > 0 && port <= 65535 ? port : null;
+}
+
+function patchStream(stream, key, state) {
+  const originalWrite = stream.write;
+  if (typeof originalWrite !== 'function' || originalWrite.__powerNativeMetroLoggerPatched) return;
+
+  function patchedWrite(chunk, encoding, callback) {
+    try {
+      const text = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk);
+      appendMetroLog(state, text);
+      setMetroLogPort(state, extractMetroPort(text));
+    } catch (error) {
+      reportInstrumentationError(state, error, `${key} capture`);
+    }
+    return originalWrite.call(stream, chunk, encoding, callback);
+  }
+
+  patchedWrite.__powerNativeMetroLoggerPatched = true;
+  patchedWrite.__powerNativeMetroLoggerOriginal = originalWrite;
+  stream.write = patchedWrite;
+}
+
+function enablePowerNativeMetroLogging(options = {}) {
+  const state = getMetroLogState(options.projectRoot, options.onError);
+  try {
+    patchStream(process.stdout, 'stdout', state);
+    patchStream(process.stderr, 'stderr', state);
+    appendMetroLog(state, `[powernative] Metro log started pid=${process.pid}\n`);
+  } catch (error) {
+    reportInstrumentationError(state, error, 'stream setup');
+  }
+  return { logDir: state.logDir, logPath: state.logPath };
+}
+
+function withPowerNativeMetroLogging(middleware, options = {}) {
+  if (typeof middleware !== 'function') return middleware;
+  const state = getMetroLogState(options.projectRoot, options.onError);
+  const maxBodyBytes = Number.isInteger(options.maxBodyBytes) && options.maxBodyBytes > 0
+    ? options.maxBodyBytes
+    : DEFAULT_MAX_ERROR_BODY_BYTES;
+  enablePowerNativeMetroLogging(options);
+
+  return (req, res, next) => {
+    try {
+      setMetroLogPort(state, Number(req.socket && req.socket.localPort));
+      const chunks = [];
+      let capturedBytes = 0;
+      const write = res.write.bind(res);
+      const end = res.end.bind(res);
+
+      function captureChunk(chunk, encoding) {
+        if (!chunk || capturedBytes >= maxBodyBytes) return;
+        const buf = Buffer.isBuffer(chunk)
+          ? chunk
+          : Buffer.from(String(chunk), typeof encoding === 'string' ? encoding : undefined);
+        const remaining = maxBodyBytes - capturedBytes;
+        if (buf.length > remaining) {
+          chunks.push(buf.subarray(0, remaining));
+          capturedBytes = maxBodyBytes;
+          return;
+        }
+        chunks.push(buf);
+        capturedBytes += buf.length;
+      }
+
+      res.write = (chunk, encoding, callback) => {
+        if (typeof encoding === 'function') {
+          callback = encoding;
+          encoding = undefined;
+        }
+        captureChunk(chunk, encoding);
+        return write(chunk, encoding, callback);
+      };
+
+      res.end = (chunk, encoding, callback) => {
+        if (typeof encoding === 'function') {
+          callback = encoding;
+          encoding = undefined;
+        }
+        captureChunk(chunk, encoding);
+        if (res.statusCode >= 400) {
+          const body = Buffer.concat(chunks).toString('utf8').slice(0, maxBodyBytes);
+          appendMetroLog(state, `\n[powernative] HTTP ${req.method} ${req.url} -> ${res.statusCode}\n${body}\n`);
+        }
+        return end(chunk, encoding, callback);
+      };
+    } catch (error) {
+      reportInstrumentationError(state, error, 'HTTP middleware setup');
+    }
+    return middleware(req, res, next);
+  };
+}
+
+module.exports = {
+  enablePowerNativeMetroLogging,
+  redactMetroLog,
+  withPowerNativeMetroLogging,
+};

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