codeplay-common 4.4.1 → 4.4.3

package/files/take-screen-video.js

@@ -1,644 +1,644 @@
-//node take-screen-video.js
-
-//--audio without //with,without
-//--duration 0 //30,120 (0 is used "Enter" key to stop)
-//--countdown 0//0,5,10
-//--name test-name
-//--profiles youtube,non-spatial-xr,amazon
-
-
-
-const fs = require('node:fs');
-const path = require('node:path');
-const { spawn, spawnSync } = require('node:child_process');
-
-const scriptDirectory = __dirname;
-const projectDirectory = scriptDirectory;
-const temporaryDirectory = path.join(projectDirectory, 'agent-temp', 'store-video');
-const outputDirectory = path.join(projectDirectory, 'Auto-Screenshot', 'Video', 'Output');
-const deviceRecordingPath = '/sdcard/codeplay_store_video.mp4';
-const capacitorConfigPath = path.join(projectDirectory, 'capacitor.config.json');
-
-const videoProfiles = {
-  youtube: {
-    label: 'YouTube preview',
-    directory: 'YouTube',
-    fileSuffix: 'youtube',
-    width: 1920,
-    height: 1080,
-    videoBitrate: '8M',
-    h264Level: '4.2',
-  },
-  'non-spatial-xr': {
-    label: 'Google Play non-spatial XR',
-    directory: 'Google-Play-XR-Non-Spatial',
-    fileSuffix: 'non-spatial-xr',
-    width: 3840,
-    height: 2160,
-    videoBitrate: '12M',
-    h264Level: '5.1',
-  },
-  amazon: {
-    label: 'Amazon Appstore',
-    directory: 'Amazon',
-    fileSuffix: 'amazon',
-    width: 1920,
-    height: 1080,
-    videoBitrate: '4M',
-    h264Level: '4.2',
-  },
-};
-
-function run(command, args, options = {}) {
-  const result = spawnSync(command, args, {
-    encoding: 'utf8',
-    windowsHide: true,
-    stdio: options.inherit ? 'inherit' : 'pipe',
-    ...options,
-  });
-
-  if (result.error) {
-    if (result.error.code === 'ENOENT') {
-      throw new Error(`${command} was not found in PATH.`);
-    }
-
-    throw result.error;
-  }
-
-  if (result.status !== 0) {
-    throw new Error(
-      String(result.stderr || result.stdout || `${command} exited with code ${result.status}.`).trim(),
-    );
-  }
-
-  return String(result.stdout || '').trim();
-}
-
-function commandExists(command) {
-  const result = spawnSync(command, ['-version'], {
-    encoding: 'utf8',
-    windowsHide: true,
-  });
-  return !result.error && result.status === 0;
-}
-
-function getExecutable(command) {
-  return commandExists(command) ? command : '';
-}
-
-function wait(milliseconds) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
-}
-
-function runAsync(command, args, options = {}) {
-  const child = spawn(command, args, {
-    windowsHide: true,
-    stdio: 'inherit',
-    ...options,
-  });
-
-  return {
-    child,
-    completion: new Promise((resolve, reject) => {
-      child.once('error', reject);
-      child.once('exit', (code) => {
-        if (code === 0) resolve();
-        else reject(new Error(`${command} exited with code ${code}.`));
-      });
-    }),
-  };
-}
-
-function getConnectedDevice() {
-  const devices = run('adb', ['devices'])
-    .split(/\r?\n/)
-    .map((line) => line.match(/^(\S+)\s+device$/))
-    .filter(Boolean)
-    .map((match) => match[1]);
-
-  if (!devices.length) {
-    throw new Error('no_connected_device');
-  }
-
-  return devices[0];
-}
-
-function getScreenRecordingPids(deviceId) {
-  const result = spawnSync('adb', ['-s', deviceId, 'shell', 'pidof', 'screenrecord'], {
-    encoding: 'utf8',
-    windowsHide: true,
-  });
-
-  if (result.error) throw result.error;
-
-  const output = String(result.stdout || '').trim();
-  if (result.status === 1 && !output) return [];
-  if (result.status !== 0) {
-    throw new Error(
-      String(result.stderr || output || `adb exited with code ${result.status}.`).trim(),
-    );
-  }
-
-  return output.split(/\s+/).filter(Boolean);
-}
-
-function waitForScreenRecordingPid(deviceId) {
-  for (let attempt = 0; attempt < 50; attempt += 1) {
-    const pids = getScreenRecordingPids(deviceId);
-    if (pids.length === 1) return pids[0];
-    if (pids.length > 1) {
-      throw new Error(`Multiple screenrecord processes are running: ${pids.join(', ')}.`);
-    }
-    wait(100);
-  }
-
-  throw new Error('Android screenrecord did not start within 5 seconds.');
-}
-
-function stopScreenRecording(deviceId, recordingPid) {
-  // SIGINT lets screenrecord write the MP4 index before its adb shell exits.
-  run('adb', ['-s', deviceId, 'shell', 'kill', '-2', recordingPid]);
-}
-
-async function waitForRecordingFinalization(recordingCompletion) {
-  let timeout;
-  try {
-    await Promise.race([
-      recordingCompletion,
-      new Promise((resolve, reject) => {
-        timeout = setTimeout(
-          () => reject(new Error('The recorder did not finalize within 15 seconds.')),
-          15000,
-        );
-      }),
-    ]);
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-function sanitizeName(value) {
-  const name = String(value || '')
-    .trim()
-    .replace(/\.mp4$/i, '')
-    .replace(/[<>:"/\\|?*\u0000-\u001F]/g, '_')
-    .replace(/[. ]+$/g, '');
-  return name || 'store-video';
-}
-
-function getCapacitorConfig() {
-  return JSON.parse(fs.readFileSync(capacitorConfigPath, 'utf8'));
-}
-
-function getDefaultVideoName() {
-  return sanitizeName(getCapacitorConfig().appName || 'store-video');
-}
-
-function parseArguments() {
-  const args = process.argv.slice(2);
-  const options = {
-    audio: 'without',
-    countdown: 5,
-    duration: 0,
-    help: false,
-    input: '',
-    list: false,
-    name: '',
-    profiles: 'youtube,non-spatial-xr,amazon',
-    spatialInput: '',
-  };
-
-  for (let index = 0; index < args.length; index += 1) {
-    const argument = args[index];
-
-    if (argument === '--audio') {
-      options.audio = String(args[index + 1] || '').toLowerCase();
-      index += 1;
-    } else if (argument === '--countdown') {
-      options.countdown = Number(args[index + 1]);
-      index += 1;
-    } else if (argument === '--duration') {
-      options.duration = Number(args[index + 1]);
-      index += 1;
-    } else if (argument === '--input') {
-      options.input = args[index + 1] || '';
-      index += 1;
-    } else if (argument === '--name') {
-      options.name = args[index + 1] || '';
-      index += 1;
-    } else if (argument === '--profiles') {
-      options.profiles = args[index + 1] || '';
-      index += 1;
-    } else if (argument === '--spatial-input') {
-      options.spatialInput = args[index + 1] || '';
-      index += 1;
-    } else if (argument === '--list') {
-      options.list = true;
-    } else if (argument === '--help' || argument === '-h') {
-      options.help = true;
-    } else {
-      throw new Error(`Unknown argument: ${argument}`);
-    }
-  }
-
-  if (!Number.isInteger(options.duration) || options.duration < 0 || options.duration > 180) {
-    throw new Error('--duration must be 0 (unlimited) or a whole number from 1 to 180 seconds.');
-  }
-
-  if (!Number.isInteger(options.countdown) || options.countdown < 0 || options.countdown > 30) {
-    throw new Error('--countdown must be a whole number from 0 to 30 seconds.');
-  }
-
-  if (!['with', 'without'].includes(options.audio)) {
-    throw new Error('--audio must be with or without.');
-  }
-
-  options.name = options.name
-    ? sanitizeName(options.name)
-    : getDefaultVideoName();
-  return options;
-}
-
-
-function selectProfiles(input) {
-  const names = String(input)
-    .split(',')
-    .map((name) => name.trim().toLowerCase())
-    .filter(Boolean);
-
-  if (names.includes('all')) {
-    return Object.keys(videoProfiles);
-  }
-
-  for (const name of names) {
-    if (!videoProfiles[name] && name !== 'spatial-xr') {
-      throw new Error(`Unknown profile: ${name}. Run with --list to see valid profiles.`);
-    }
-  }
-
-  return [...new Set(names)];
-}
-
-function printProfiles() {
-  for (const [name, profile] of Object.entries(videoProfiles)) {
-    console.log(
-      `${name.padEnd(16)} ${profile.label} (${profile.width}x${profile.height}, H.264 MP4)`,
-    );
-  }
-
-  console.log('spatial-xr       Genuine 360/180/3D source passthrough (requires --spatial-input)');
-}
-
-function printHelp() {
-  console.log('Record the connected Android device and create store-ready video variants.');
-  console.log('');
-  console.log('Usage:');
-  console.log('  node take-screen-video.js --name gameplay --duration 30');
-  console.log('  node take-screen-video.js --audio with');
-  console.log('  node take-screen-video.js --input recording.mp4 --profiles youtube,amazon');
-  console.log('  node take-screen-video.js --profiles spatial-xr --spatial-input genuine-360.mp4');
-  console.log('  node take-screen-video.js --profiles all');
-  console.log('  node take-screen-video.js --list');
-  console.log('');
-  console.log('Defaults: --audio without --duration 0 (unlimited)');
-  console.log(`Default name: ${getDefaultVideoName()} (capacitor.config.json appName)`);
-  console.log('Manual mode: press Enter to stop; a positive --duration sets a safety maximum.');
-  console.log('Audio recording uses scrcpy and requires Android 11 or newer.');
-}
-
-function waitForManualStop(recordingCompletion, duration) {
-  if (!process.stdin.isTTY) {
-    throw new Error('Manual interaction requires an interactive terminal so Enter can stop recording.');
-  }
-
-  return new Promise((resolve, reject) => {
-    const finish = (reason) => {
-      if (timeout) clearTimeout(timeout);
-      process.stdin.removeListener('data', onInput);
-      process.stdin.pause();
-      resolve(reason);
-    };
-    const onInput = (input) => {
-      if (/\r|\n/.test(String(input))) finish('enter');
-    };
-    const timeout = duration > 0
-      ? setTimeout(() => finish('maximum-duration'), duration * 1000)
-      : null;
-
-    process.stdin.resume();
-    process.stdin.on('data', onInput);
-    recordingCompletion.then(
-      () => finish('recorder-completed'),
-      (error) => {
-        if (timeout) clearTimeout(timeout);
-        process.stdin.removeListener('data', onInput);
-        process.stdin.pause();
-        reject(error);
-      },
-    );
-  });
-}
-
-function getScrcpyCommand() {
-  return commandExists('scrcpy') ? 'scrcpy' : '';
-}
-
-async function recordConnectedDevice(options, destinationPath) {
-  const { audio, countdown, duration } = options;
-  const deviceId = getConnectedDevice();
-  fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
-  if (fs.existsSync(destinationPath)) {
-    fs.unlinkSync(destinationPath);
-  }
-
-  console.log(`Connected device: ${deviceId}`);
-  console.log(`Interaction: manual; audio: ${audio}.`);
-  console.log('Open the required first app screen, then operate the physical device while recording.');
-
-  for (let seconds = countdown; seconds > 0; seconds -= 1) {
-    console.log(`Recording starts in ${seconds}...`);
-    wait(1000);
-  }
-
-  console.log(
-    duration > 0
-      ? `RECORDING NOW — maximum ${duration} seconds.`
-      : 'RECORDING NOW — unlimited duration; press Enter to stop.',
-  );
-
-  let recording;
-  let recordingPid = '';
-  if (audio === 'with') {
-    const scrcpyCommand = getScrcpyCommand();
-    if (!scrcpyCommand) {
-      throw new Error(
-        'Audio recording requires scrcpy. Install scrcpy and add it to PATH.',
-      );
-    }
-
-    const scrcpyArguments = [
-      '--serial', deviceId,
-      '--no-window',
-      '--no-playback',
-      '--no-control',
-      '--require-audio',
-      '--record', destinationPath,
-    ];
-    if (duration > 0) {
-      scrcpyArguments.push('--time-limit', String(duration));
-    }
-    recording = runAsync(scrcpyCommand, scrcpyArguments);
-  } else {
-    const existingPids = getScreenRecordingPids(deviceId);
-    if (existingPids.length) {
-      throw new Error(
-        `Android screenrecord is already running (PID ${existingPids.join(', ')}). Stop it before recording.`,
-      );
-    }
-    run('adb', ['-s', deviceId, 'shell', 'rm', '-f', deviceRecordingPath]);
-    recording = runAsync('adb', [
-      '-s', deviceId,
-      'shell', 'screenrecord',
-      '--bit-rate', '12000000',
-      '--time-limit', String(duration),
-      deviceRecordingPath,
-    ], { stdio: ['ignore', 'inherit', 'inherit'] });
-    recordingPid = waitForScreenRecordingPid(deviceId);
-  }
-
-  let manualStopRequested = false;
-  console.log('MANUAL RECORDING — use the device, then press Enter here to stop and convert.');
-  const stopReason = await waitForManualStop(recording.completion, duration);
-
-  if (stopReason === 'enter') {
-    manualStopRequested = true;
-    console.log('Enter pressed — stopping and finalizing the recording...');
-    if (audio === 'with') {
-      run('adb', [
-        '-s', deviceId,
-        'shell', 'pkill', '-TERM', '-f', 'com.genymobile.scrcpy.Server',
-      ]);
-    } else {
-      stopScreenRecording(deviceId, recordingPid);
-    }
-  } else if (stopReason === 'maximum-duration') {
-    console.log(`Safety maximum reached after ${duration} seconds.`);
-  }
-
-  await waitForRecordingFinalization(recording.completion);
-
-  if (audio === 'without') {
-    try {
-      run('adb', ['-s', deviceId, 'pull', deviceRecordingPath, destinationPath], { inherit: true });
-    } finally {
-      try {
-        run('adb', ['-s', deviceId, 'shell', 'rm', deviceRecordingPath]);
-      } catch {
-        // The device may have disconnected after recording.
-      }
-    }
-  }
-
-  console.log('RECORDING FINISHED — converting the captured video.');
-  console.log(`Recorded connected device ${deviceId}: ${destinationPath}`);
-}
-
-function getUniqueOutputPath(profile, name) {
-  const profileDirectory = path.join(outputDirectory, profile.directory);
-  fs.mkdirSync(profileDirectory, { recursive: true });
-
-  let outputPath = path.join(profileDirectory, `${name}-${profile.fileSuffix}.mp4`);
-  let duplicateNumber = 2;
-
-  while (fs.existsSync(outputPath)) {
-    outputPath = path.join(
-      profileDirectory,
-      `${name}-${profile.fileSuffix}-${duplicateNumber}.mp4`,
-    );
-    duplicateNumber += 1;
-  }
-
-  return outputPath;
-}
-
-function getVideoDetails(ffprobeCommand, videoPath) {
-  const output = run(ffprobeCommand, [
-    '-v', 'error',
-    '-show_entries', 'stream=width,height,codec_name,codec_type,bit_rate',
-    '-show_entries', 'format=duration,size,bit_rate',
-    '-of', 'json',
-    videoPath,
-  ]);
-  return JSON.parse(output);
-}
-
-function validateVideo(ffprobeCommand, videoPath, profile) {
-  const details = getVideoDetails(ffprobeCommand, videoPath);
-  const stream = details.streams?.find((candidate) => candidate.codec_type === 'video') || {};
-  const format = details.format || {};
-  const bitRate = Number(stream.bit_rate || format.bit_rate || 0);
-
-  if (stream.codec_name !== 'h264') {
-    throw new Error(`Validation failed for ${videoPath}: expected H.264 video.`);
-  }
-
-  if (Number(stream.width) !== profile.width || Number(stream.height) !== profile.height) {
-    throw new Error(
-      `Validation failed for ${videoPath}: expected ${profile.width}x${profile.height}.`,
-    );
-  }
-
-  if (profile === videoProfiles.amazon && bitRate < 1200000) {
-    throw new Error(`Amazon video bitrate is below 1200 kbps: ${Math.round(bitRate / 1000)} kbps.`);
-  }
-
-  console.log(
-    `Validated ${profile.label}: ${stream.width}x${stream.height}, H.264, `
-    + `${(Number(format.duration) || 0).toFixed(1)}s, ${Math.round(bitRate / 1000)} kbps.`,
-  );
-}
-
-function createVideoVariant(
-  ffmpegCommand,
-  ffprobeCommand,
-  inputPath,
-  profile,
-  name,
-  requireAudio,
-) {
-  const destinationPath = getUniqueOutputPath(profile, name);
-  const videoFilter = [
-    'setparams=colorspace=bt709:color_primaries=bt709:color_trc=bt709:range=tv',
-    `scale=${profile.width}:${profile.height}:force_original_aspect_ratio=decrease`,
-    `pad=${profile.width}:${profile.height}:(ow-iw)/2:(oh-ih)/2:color=black`,
-    'setsar=1',
-  ].join(',');
-
-  run(ffmpegCommand, [
-    '-hide_banner',
-    '-y',
-    '-i', inputPath,
-    '-map', '0:v:0',
-    '-map', '0:a?',
-    '-vf', videoFilter,
-    '-c:v', 'libx264',
-    '-preset', 'medium',
-    '-profile:v', 'high',
-    '-level', profile.h264Level,
-    '-pix_fmt', 'yuv420p',
-    '-b:v', profile.videoBitrate,
-    '-minrate', profile.videoBitrate,
-    '-maxrate', profile.videoBitrate,
-    '-bufsize', profile.videoBitrate,
-    '-x264-params', 'nal-hrd=cbr:force-cfr=1',
-    '-r', '30',
-    '-c:a', 'aac',
-    '-b:a', '192k',
-    '-movflags', '+faststart',
-    destinationPath,
-  ], { inherit: true });
-
-  console.log(`Created ${profile.label}: ${destinationPath}`);
-  validateVideo(ffprobeCommand, destinationPath, profile);
-
-  if (requireAudio) {
-    const details = getVideoDetails(ffprobeCommand, destinationPath);
-    const audioStream = details.streams?.find((stream) => stream.codec_type === 'audio');
-    if (!audioStream) {
-      throw new Error(`Validation failed for ${destinationPath}: audio track is missing.`);
-    }
-    console.log(`Validated audio: ${audioStream.codec_name} track included.`);
-  }
-}
-
-function copySpatialSource(spatialInput, name) {
-  if (!spatialInput) {
-    throw new Error(
-      'Spatial XR requires --spatial-input with a genuine 360-degree, 180-degree, or 3D video.',
-    );
-  }
-
-  const sourcePath = path.resolve(spatialInput);
-  if (!fs.existsSync(sourcePath) || !fs.statSync(sourcePath).isFile()) {
-    throw new Error(`Spatial XR source was not found: ${sourcePath}`);
-  }
-
-  const spatialDirectory = path.join(outputDirectory, 'Google-Play-XR-Spatial');
-  fs.mkdirSync(spatialDirectory, { recursive: true });
-  const extension = path.extname(sourcePath) || '.mp4';
-  let destinationPath = path.join(spatialDirectory, `${name}-spatial-xr${extension}`);
-  let duplicateNumber = 2;
-
-  while (fs.existsSync(destinationPath)) {
-    destinationPath = path.join(
-      spatialDirectory,
-      `${name}-spatial-xr-${duplicateNumber}${extension}`,
-    );
-    duplicateNumber += 1;
-  }
-
-  fs.copyFileSync(sourcePath, destinationPath, fs.constants.COPYFILE_EXCL);
-  console.log(`Copied genuine Spatial XR source without stripping its metadata: ${destinationPath}`);
-}
-
-async function main() {
-  const options = parseArguments();
-
-  if (options.help) {
-    printHelp();
-    return;
-  }
-
-  if (options.list) {
-    printProfiles();
-    return;
-  }
-
-
-  const selectedProfiles = selectProfiles(options.profiles);
-  const flatProfiles = selectedProfiles.filter((name) => name !== 'spatial-xr');
-
-  if (selectedProfiles.includes('spatial-xr')) {
-    copySpatialSource(options.spatialInput, options.name);
-  }
-
-  if (!flatProfiles.length) {
-    return;
-  }
-
-  const ffmpegCommand = getExecutable('ffmpeg');
-  const ffprobeCommand = getExecutable('ffprobe');
-
-  if (!ffmpegCommand || !ffprobeCommand) {
-    throw new Error(
-      'FFmpeg was not found in PATH. Install FFmpeg, reopen the terminal, and run this script again.',
-    );
-  }
-
-  let inputPath;
-  if (options.input) {
-    inputPath = path.resolve(options.input);
-    if (!fs.existsSync(inputPath) || !fs.statSync(inputPath).isFile()) {
-      throw new Error(`Input video was not found: ${inputPath}`);
-    }
-  } else {
-    inputPath = path.join(temporaryDirectory, `${options.name}-adb-source.mp4`);
-    await recordConnectedDevice(options, inputPath);
-  }
-
-  for (const profileName of flatProfiles) {
-    createVideoVariant(
-      ffmpegCommand,
-      ffprobeCommand,
-      inputPath,
-      videoProfiles[profileName],
-      options.name,
-      options.audio === 'with',
-    );
-  }
-}
-
-main().catch((error) => {
-  console.error(`Store video creation failed: ${error.message}`);
-  process.exitCode = 1;
-});
+//node take-screen-video.js
+
+//--audio without //with,without
+//--duration 0 //30,120 (0 is used "Enter" key to stop)
+//--countdown 0//0,5,10
+//--name test-name
+//--profiles youtube,non-spatial-xr,amazon
+
+
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawn, spawnSync } = require('node:child_process');
+
+const scriptDirectory = __dirname;
+const projectDirectory = scriptDirectory;
+const temporaryDirectory = path.join(projectDirectory, 'agent-temp', 'store-video');
+const outputDirectory = path.join(projectDirectory, 'Auto-Screenshot', 'Video', 'Output');
+const deviceRecordingPath = '/sdcard/codeplay_store_video.mp4';
+const capacitorConfigPath = path.join(projectDirectory, 'capacitor.config.json');
+
+const videoProfiles = {
+  youtube: {
+    label: 'YouTube preview',
+    directory: 'YouTube',
+    fileSuffix: 'youtube',
+    width: 1920,
+    height: 1080,
+    videoBitrate: '8M',
+    h264Level: '4.2',
+  },
+  'non-spatial-xr': {
+    label: 'Google Play non-spatial XR',
+    directory: 'Google-Play-XR-Non-Spatial',
+    fileSuffix: 'non-spatial-xr',
+    width: 3840,
+    height: 2160,
+    videoBitrate: '12M',
+    h264Level: '5.1',
+  },
+  amazon: {
+    label: 'Amazon Appstore',
+    directory: 'Amazon',
+    fileSuffix: 'amazon',
+    width: 1920,
+    height: 1080,
+    videoBitrate: '4M',
+    h264Level: '4.2',
+  },
+};
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    encoding: 'utf8',
+    windowsHide: true,
+    stdio: options.inherit ? 'inherit' : 'pipe',
+    ...options,
+  });
+
+  if (result.error) {
+    if (result.error.code === 'ENOENT') {
+      throw new Error(`${command} was not found in PATH.`);
+    }
+
+    throw result.error;
+  }
+
+  if (result.status !== 0) {
+    throw new Error(
+      String(result.stderr || result.stdout || `${command} exited with code ${result.status}.`).trim(),
+    );
+  }
+
+  return String(result.stdout || '').trim();
+}
+
+function commandExists(command) {
+  const result = spawnSync(command, ['-version'], {
+    encoding: 'utf8',
+    windowsHide: true,
+  });
+  return !result.error && result.status === 0;
+}
+
+function getExecutable(command) {
+  return commandExists(command) ? command : '';
+}
+
+function wait(milliseconds) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+}
+
+function runAsync(command, args, options = {}) {
+  const child = spawn(command, args, {
+    windowsHide: true,
+    stdio: 'inherit',
+    ...options,
+  });
+
+  return {
+    child,
+    completion: new Promise((resolve, reject) => {
+      child.once('error', reject);
+      child.once('exit', (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`${command} exited with code ${code}.`));
+      });
+    }),
+  };
+}
+
+function getConnectedDevice() {
+  const devices = run('adb', ['devices'])
+    .split(/\r?\n/)
+    .map((line) => line.match(/^(\S+)\s+device$/))
+    .filter(Boolean)
+    .map((match) => match[1]);
+
+  if (!devices.length) {
+    throw new Error('no_connected_device');
+  }
+
+  return devices[0];
+}
+
+function getScreenRecordingPids(deviceId) {
+  const result = spawnSync('adb', ['-s', deviceId, 'shell', 'pidof', 'screenrecord'], {
+    encoding: 'utf8',
+    windowsHide: true,
+  });
+
+  if (result.error) throw result.error;
+
+  const output = String(result.stdout || '').trim();
+  if (result.status === 1 && !output) return [];
+  if (result.status !== 0) {
+    throw new Error(
+      String(result.stderr || output || `adb exited with code ${result.status}.`).trim(),
+    );
+  }
+
+  return output.split(/\s+/).filter(Boolean);
+}
+
+function waitForScreenRecordingPid(deviceId) {
+  for (let attempt = 0; attempt < 50; attempt += 1) {
+    const pids = getScreenRecordingPids(deviceId);
+    if (pids.length === 1) return pids[0];
+    if (pids.length > 1) {
+      throw new Error(`Multiple screenrecord processes are running: ${pids.join(', ')}.`);
+    }
+    wait(100);
+  }
+
+  throw new Error('Android screenrecord did not start within 5 seconds.');
+}
+
+function stopScreenRecording(deviceId, recordingPid) {
+  // SIGINT lets screenrecord write the MP4 index before its adb shell exits.
+  run('adb', ['-s', deviceId, 'shell', 'kill', '-2', recordingPid]);
+}
+
+async function waitForRecordingFinalization(recordingCompletion) {
+  let timeout;
+  try {
+    await Promise.race([
+      recordingCompletion,
+      new Promise((resolve, reject) => {
+        timeout = setTimeout(
+          () => reject(new Error('The recorder did not finalize within 15 seconds.')),
+          15000,
+        );
+      }),
+    ]);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+function sanitizeName(value) {
+  const name = String(value || '')
+    .trim()
+    .replace(/\.mp4$/i, '')
+    .replace(/[<>:"/\\|?*\u0000-\u001F]/g, '_')
+    .replace(/[. ]+$/g, '');
+  return name || 'store-video';
+}
+
+function getCapacitorConfig() {
+  return JSON.parse(fs.readFileSync(capacitorConfigPath, 'utf8'));
+}
+
+function getDefaultVideoName() {
+  return sanitizeName(getCapacitorConfig().appName || 'store-video');
+}
+
+function parseArguments() {
+  const args = process.argv.slice(2);
+  const options = {
+    audio: 'without',
+    countdown: 5,
+    duration: 0,
+    help: false,
+    input: '',
+    list: false,
+    name: '',
+    profiles: 'youtube,non-spatial-xr,amazon',
+    spatialInput: '',
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+
+    if (argument === '--audio') {
+      options.audio = String(args[index + 1] || '').toLowerCase();
+      index += 1;
+    } else if (argument === '--countdown') {
+      options.countdown = Number(args[index + 1]);
+      index += 1;
+    } else if (argument === '--duration') {
+      options.duration = Number(args[index + 1]);
+      index += 1;
+    } else if (argument === '--input') {
+      options.input = args[index + 1] || '';
+      index += 1;
+    } else if (argument === '--name') {
+      options.name = args[index + 1] || '';
+      index += 1;
+    } else if (argument === '--profiles') {
+      options.profiles = args[index + 1] || '';
+      index += 1;
+    } else if (argument === '--spatial-input') {
+      options.spatialInput = args[index + 1] || '';
+      index += 1;
+    } else if (argument === '--list') {
+      options.list = true;
+    } else if (argument === '--help' || argument === '-h') {
+      options.help = true;
+    } else {
+      throw new Error(`Unknown argument: ${argument}`);
+    }
+  }
+
+  if (!Number.isInteger(options.duration) || options.duration < 0 || options.duration > 180) {
+    throw new Error('--duration must be 0 (unlimited) or a whole number from 1 to 180 seconds.');
+  }
+
+  if (!Number.isInteger(options.countdown) || options.countdown < 0 || options.countdown > 30) {
+    throw new Error('--countdown must be a whole number from 0 to 30 seconds.');
+  }
+
+  if (!['with', 'without'].includes(options.audio)) {
+    throw new Error('--audio must be with or without.');
+  }
+
+  options.name = options.name
+    ? sanitizeName(options.name)
+    : getDefaultVideoName();
+  return options;
+}
+
+
+function selectProfiles(input) {
+  const names = String(input)
+    .split(',')
+    .map((name) => name.trim().toLowerCase())
+    .filter(Boolean);
+
+  if (names.includes('all')) {
+    return Object.keys(videoProfiles);
+  }
+
+  for (const name of names) {
+    if (!videoProfiles[name] && name !== 'spatial-xr') {
+      throw new Error(`Unknown profile: ${name}. Run with --list to see valid profiles.`);
+    }
+  }
+
+  return [...new Set(names)];
+}
+
+function printProfiles() {
+  for (const [name, profile] of Object.entries(videoProfiles)) {
+    console.log(
+      `${name.padEnd(16)} ${profile.label} (${profile.width}x${profile.height}, H.264 MP4)`,
+    );
+  }
+
+  console.log('spatial-xr       Genuine 360/180/3D source passthrough (requires --spatial-input)');
+}
+
+function printHelp() {
+  console.log('Record the connected Android device and create store-ready video variants.');
+  console.log('');
+  console.log('Usage:');
+  console.log('  node take-screen-video.js --name gameplay --duration 30');
+  console.log('  node take-screen-video.js --audio with');
+  console.log('  node take-screen-video.js --input recording.mp4 --profiles youtube,amazon');
+  console.log('  node take-screen-video.js --profiles spatial-xr --spatial-input genuine-360.mp4');
+  console.log('  node take-screen-video.js --profiles all');
+  console.log('  node take-screen-video.js --list');
+  console.log('');
+  console.log('Defaults: --audio without --duration 0 (unlimited)');
+  console.log(`Default name: ${getDefaultVideoName()} (capacitor.config.json appName)`);
+  console.log('Manual mode: press Enter to stop; a positive --duration sets a safety maximum.');
+  console.log('Audio recording uses scrcpy and requires Android 11 or newer.');
+}
+
+function waitForManualStop(recordingCompletion, duration) {
+  if (!process.stdin.isTTY) {
+    throw new Error('Manual interaction requires an interactive terminal so Enter can stop recording.');
+  }
+
+  return new Promise((resolve, reject) => {
+    const finish = (reason) => {
+      if (timeout) clearTimeout(timeout);
+      process.stdin.removeListener('data', onInput);
+      process.stdin.pause();
+      resolve(reason);
+    };
+    const onInput = (input) => {
+      if (/\r|\n/.test(String(input))) finish('enter');
+    };
+    const timeout = duration > 0
+      ? setTimeout(() => finish('maximum-duration'), duration * 1000)
+      : null;
+
+    process.stdin.resume();
+    process.stdin.on('data', onInput);
+    recordingCompletion.then(
+      () => finish('recorder-completed'),
+      (error) => {
+        if (timeout) clearTimeout(timeout);
+        process.stdin.removeListener('data', onInput);
+        process.stdin.pause();
+        reject(error);
+      },
+    );
+  });
+}
+
+function getScrcpyCommand() {
+  return commandExists('scrcpy') ? 'scrcpy' : '';
+}
+
+async function recordConnectedDevice(options, destinationPath) {
+  const { audio, countdown, duration } = options;
+  const deviceId = getConnectedDevice();
+  fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+  if (fs.existsSync(destinationPath)) {
+    fs.unlinkSync(destinationPath);
+  }
+
+  console.log(`Connected device: ${deviceId}`);
+  console.log(`Interaction: manual; audio: ${audio}.`);
+  console.log('Open the required first app screen, then operate the physical device while recording.');
+
+  for (let seconds = countdown; seconds > 0; seconds -= 1) {
+    console.log(`Recording starts in ${seconds}...`);
+    wait(1000);
+  }
+
+  console.log(
+    duration > 0
+      ? `RECORDING NOW — maximum ${duration} seconds.`
+      : 'RECORDING NOW — unlimited duration; press Enter to stop.',
+  );
+
+  let recording;
+  let recordingPid = '';
+  if (audio === 'with') {
+    const scrcpyCommand = getScrcpyCommand();
+    if (!scrcpyCommand) {
+      throw new Error(
+        'Audio recording requires scrcpy. Install scrcpy and add it to PATH.',
+      );
+    }
+
+    const scrcpyArguments = [
+      '--serial', deviceId,
+      '--no-window',
+      '--no-playback',
+      '--no-control',
+      '--require-audio',
+      '--record', destinationPath,
+    ];
+    if (duration > 0) {
+      scrcpyArguments.push('--time-limit', String(duration));
+    }
+    recording = runAsync(scrcpyCommand, scrcpyArguments);
+  } else {
+    const existingPids = getScreenRecordingPids(deviceId);
+    if (existingPids.length) {
+      throw new Error(
+        `Android screenrecord is already running (PID ${existingPids.join(', ')}). Stop it before recording.`,
+      );
+    }
+    run('adb', ['-s', deviceId, 'shell', 'rm', '-f', deviceRecordingPath]);
+    recording = runAsync('adb', [
+      '-s', deviceId,
+      'shell', 'screenrecord',
+      '--bit-rate', '12000000',
+      '--time-limit', String(duration),
+      deviceRecordingPath,
+    ], { stdio: ['ignore', 'inherit', 'inherit'] });
+    recordingPid = waitForScreenRecordingPid(deviceId);
+  }
+
+  let manualStopRequested = false;
+  console.log('MANUAL RECORDING — use the device, then press Enter here to stop and convert.');
+  const stopReason = await waitForManualStop(recording.completion, duration);
+
+  if (stopReason === 'enter') {
+    manualStopRequested = true;
+    console.log('Enter pressed — stopping and finalizing the recording...');
+    if (audio === 'with') {
+      run('adb', [
+        '-s', deviceId,
+        'shell', 'pkill', '-TERM', '-f', 'com.genymobile.scrcpy.Server',
+      ]);
+    } else {
+      stopScreenRecording(deviceId, recordingPid);
+    }
+  } else if (stopReason === 'maximum-duration') {
+    console.log(`Safety maximum reached after ${duration} seconds.`);
+  }
+
+  await waitForRecordingFinalization(recording.completion);
+
+  if (audio === 'without') {
+    try {
+      run('adb', ['-s', deviceId, 'pull', deviceRecordingPath, destinationPath], { inherit: true });
+    } finally {
+      try {
+        run('adb', ['-s', deviceId, 'shell', 'rm', deviceRecordingPath]);
+      } catch {
+        // The device may have disconnected after recording.
+      }
+    }
+  }
+
+  console.log('RECORDING FINISHED — converting the captured video.');
+  console.log(`Recorded connected device ${deviceId}: ${destinationPath}`);
+}
+
+function getUniqueOutputPath(profile, name) {
+  const profileDirectory = path.join(outputDirectory, profile.directory);
+  fs.mkdirSync(profileDirectory, { recursive: true });
+
+  let outputPath = path.join(profileDirectory, `${name}-${profile.fileSuffix}.mp4`);
+  let duplicateNumber = 2;
+
+  while (fs.existsSync(outputPath)) {
+    outputPath = path.join(
+      profileDirectory,
+      `${name}-${profile.fileSuffix}-${duplicateNumber}.mp4`,
+    );
+    duplicateNumber += 1;
+  }
+
+  return outputPath;
+}
+
+function getVideoDetails(ffprobeCommand, videoPath) {
+  const output = run(ffprobeCommand, [
+    '-v', 'error',
+    '-show_entries', 'stream=width,height,codec_name,codec_type,bit_rate',
+    '-show_entries', 'format=duration,size,bit_rate',
+    '-of', 'json',
+    videoPath,
+  ]);
+  return JSON.parse(output);
+}
+
+function validateVideo(ffprobeCommand, videoPath, profile) {
+  const details = getVideoDetails(ffprobeCommand, videoPath);
+  const stream = details.streams?.find((candidate) => candidate.codec_type === 'video') || {};
+  const format = details.format || {};
+  const bitRate = Number(stream.bit_rate || format.bit_rate || 0);
+
+  if (stream.codec_name !== 'h264') {
+    throw new Error(`Validation failed for ${videoPath}: expected H.264 video.`);
+  }
+
+  if (Number(stream.width) !== profile.width || Number(stream.height) !== profile.height) {
+    throw new Error(
+      `Validation failed for ${videoPath}: expected ${profile.width}x${profile.height}.`,
+    );
+  }
+
+  if (profile === videoProfiles.amazon && bitRate < 1200000) {
+    throw new Error(`Amazon video bitrate is below 1200 kbps: ${Math.round(bitRate / 1000)} kbps.`);
+  }
+
+  console.log(
+    `Validated ${profile.label}: ${stream.width}x${stream.height}, H.264, `
+    + `${(Number(format.duration) || 0).toFixed(1)}s, ${Math.round(bitRate / 1000)} kbps.`,
+  );
+}
+
+function createVideoVariant(
+  ffmpegCommand,
+  ffprobeCommand,
+  inputPath,
+  profile,
+  name,
+  requireAudio,
+) {
+  const destinationPath = getUniqueOutputPath(profile, name);
+  const videoFilter = [
+    'setparams=colorspace=bt709:color_primaries=bt709:color_trc=bt709:range=tv',
+    `scale=${profile.width}:${profile.height}:force_original_aspect_ratio=decrease`,
+    `pad=${profile.width}:${profile.height}:(ow-iw)/2:(oh-ih)/2:color=black`,
+    'setsar=1',
+  ].join(',');
+
+  run(ffmpegCommand, [
+    '-hide_banner',
+    '-y',
+    '-i', inputPath,
+    '-map', '0:v:0',
+    '-map', '0:a?',
+    '-vf', videoFilter,
+    '-c:v', 'libx264',
+    '-preset', 'medium',
+    '-profile:v', 'high',
+    '-level', profile.h264Level,
+    '-pix_fmt', 'yuv420p',
+    '-b:v', profile.videoBitrate,
+    '-minrate', profile.videoBitrate,
+    '-maxrate', profile.videoBitrate,
+    '-bufsize', profile.videoBitrate,
+    '-x264-params', 'nal-hrd=cbr:force-cfr=1',
+    '-r', '30',
+    '-c:a', 'aac',
+    '-b:a', '192k',
+    '-movflags', '+faststart',
+    destinationPath,
+  ], { inherit: true });
+
+  console.log(`Created ${profile.label}: ${destinationPath}`);
+  validateVideo(ffprobeCommand, destinationPath, profile);
+
+  if (requireAudio) {
+    const details = getVideoDetails(ffprobeCommand, destinationPath);
+    const audioStream = details.streams?.find((stream) => stream.codec_type === 'audio');
+    if (!audioStream) {
+      throw new Error(`Validation failed for ${destinationPath}: audio track is missing.`);
+    }
+    console.log(`Validated audio: ${audioStream.codec_name} track included.`);
+  }
+}
+
+function copySpatialSource(spatialInput, name) {
+  if (!spatialInput) {
+    throw new Error(
+      'Spatial XR requires --spatial-input with a genuine 360-degree, 180-degree, or 3D video.',
+    );
+  }
+
+  const sourcePath = path.resolve(spatialInput);
+  if (!fs.existsSync(sourcePath) || !fs.statSync(sourcePath).isFile()) {
+    throw new Error(`Spatial XR source was not found: ${sourcePath}`);
+  }
+
+  const spatialDirectory = path.join(outputDirectory, 'Google-Play-XR-Spatial');
+  fs.mkdirSync(spatialDirectory, { recursive: true });
+  const extension = path.extname(sourcePath) || '.mp4';
+  let destinationPath = path.join(spatialDirectory, `${name}-spatial-xr${extension}`);
+  let duplicateNumber = 2;
+
+  while (fs.existsSync(destinationPath)) {
+    destinationPath = path.join(
+      spatialDirectory,
+      `${name}-spatial-xr-${duplicateNumber}${extension}`,
+    );
+    duplicateNumber += 1;
+  }
+
+  fs.copyFileSync(sourcePath, destinationPath, fs.constants.COPYFILE_EXCL);
+  console.log(`Copied genuine Spatial XR source without stripping its metadata: ${destinationPath}`);
+}
+
+async function main() {
+  const options = parseArguments();
+
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
+  if (options.list) {
+    printProfiles();
+    return;
+  }
+
+
+  const selectedProfiles = selectProfiles(options.profiles);
+  const flatProfiles = selectedProfiles.filter((name) => name !== 'spatial-xr');
+
+  if (selectedProfiles.includes('spatial-xr')) {
+    copySpatialSource(options.spatialInput, options.name);
+  }
+
+  if (!flatProfiles.length) {
+    return;
+  }
+
+  const ffmpegCommand = getExecutable('ffmpeg');
+  const ffprobeCommand = getExecutable('ffprobe');
+
+  if (!ffmpegCommand || !ffprobeCommand) {
+    throw new Error(
+      'FFmpeg was not found in PATH. Install FFmpeg, reopen the terminal, and run this script again.',
+    );
+  }
+
+  let inputPath;
+  if (options.input) {
+    inputPath = path.resolve(options.input);
+    if (!fs.existsSync(inputPath) || !fs.statSync(inputPath).isFile()) {
+      throw new Error(`Input video was not found: ${inputPath}`);
+    }
+  } else {
+    inputPath = path.join(temporaryDirectory, `${options.name}-adb-source.mp4`);
+    await recordConnectedDevice(options, inputPath);
+  }
+
+  for (const profileName of flatProfiles) {
+    createVideoVariant(
+      ffmpegCommand,
+      ffprobeCommand,
+      inputPath,
+      videoProfiles[profileName],
+      options.name,
+      options.audio === 'with',
+    );
+  }
+}
+
+main().catch((error) => {
+  console.error(`Store video creation failed: ${error.message}`);
+  process.exitCode = 1;
+});