@happier-dev/stack 0.2.1-preview.1775586714.26562 → 0.2.11

package/scripts/testkit/runtime_snapshot_start_testkit.mjs

@@ -1,15 +1,24 @@
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { chmod, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 import { resolveStackCredentialPaths } from '../utils/auth/credentials_paths.mjs';
 import { buildStackStableScopeId } from '../utils/auth/stable_scope_id.mjs';
 import { pickNextFreeTcpPort } from '../utils/net/ports.mjs';
 import { runNodeCapture } from './core/run_node_capture.mjs';
 import { writeRuntimeSnapshotLayout } from './core/runtime_snapshot_layout.mjs';
+import { writeStubHappierCliFiles } from './core/stub_happier_cli_files.mjs';
 import { createTempFixture } from './core/temp_fixture.mjs';
 
 export const runNode = runNodeCapture;
 
+const DAEMON_LIKE_PROCESS_HELPER_PATH = fileURLToPath(
+  new URL('./core/spawn_daemon_like_process.mjs', import.meta.url),
+);
+const DAEMON_STATE_PATHS_HELPER_PATH = fileURLToPath(
+  new URL('../utils/auth/credentials_paths.mjs', import.meta.url),
+);
+
 export async function waitForHealth(baseUrl, { timeoutMs = 30_000, intervalMs = 250 } = {}) {
   const startedAt = Date.now();
   let lastError = '';
@@ -34,9 +43,10 @@ function createFixtureDaemonCliScript({
   includeRunningInStatusLog = false,
 }) {
   return `
-import { spawn } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { killDetachedProcessGroup, spawnDaemonLikeProcess } from ${JSON.stringify(DAEMON_LIKE_PROCESS_HELPER_PATH)};
+import { resolveStackDaemonStatePaths } from ${JSON.stringify(DAEMON_STATE_PATHS_HELPER_PATH)};
 
 const args = process.argv.slice(2);
 const home = String(process.env.HAPPIER_HOME_DIR || process.env.HAPPIER_STACK_CLI_HOME_DIR || '').trim();
@@ -44,24 +54,19 @@ if (!home) {
   console.error('missing HAPPIER_HOME_DIR');
   process.exit(2);
 }
-const statePath = join(home, 'daemon.state.json');
-const activeServerId = String(process.env.HAPPIER_ACTIVE_SERVER_ID || '').trim();
-const serverScopedStatePath = activeServerId ? join(home, 'servers', activeServerId, 'daemon.state.json') : '';
+const resolvedStatePaths = resolveStackDaemonStatePaths({
+  cliHomeDir: home,
+  serverUrl: String(process.env.HAPPIER_SERVER_URL || ''),
+  env: process.env,
+});
+const statePaths = [...new Set(resolvedStatePaths.pairs.map((pair) => pair.statePath).filter(Boolean))];
 const logPath = join(home, 'runtime-daemon.log');
 const append = (line) => {
   writeFileSync(logPath, line + '\\n', { flag: 'a' });
 };
-const writeState = (payload) => {
-  writeFileSync(statePath, payload, 'utf8');
-  if (serverScopedStatePath) {
-    mkdirSync(dirname(serverScopedStatePath), { recursive: true });
-    writeFileSync(serverScopedStatePath, payload, 'utf8');
-  }
-};
 const removeState = () => {
-  try { rmSync(statePath); } catch {}
-  if (serverScopedStatePath) {
-    try { rmSync(serverScopedStatePath); } catch {}
+  for (const path of statePaths) {
+    try { rmSync(path); } catch {}
   }
 };
 if (args[0] !== 'daemon') process.exit(0);
@@ -74,18 +79,31 @@ if (sub === 'start') {
   append('direct_peer_advertised_hosts=' + String(process.env.HAPPIER_MACHINE_TRANSFER_DIRECT_PEER_ADVERTISED_HOSTS || ''));
   append('direct_peer_feature_enabled=' + String(process.env.HAPPIER_FEATURE_MACHINES_TRANSFER_DIRECT_PEER__ENABLED || ''));
   append('direct_peer_server_enabled=' + String(process.env.HAPPIER_MACHINE_TRANSFER_DIRECT_PEER_SERVER_ENABLED || ''));
-  const child = spawn(process.execPath, ['-e', 'setInterval(() => {}, 1000)'], { detached: true, stdio: 'ignore' });
-  child.unref();
-  writeState(JSON.stringify({ pid: child.pid, httpPort: 0, startedAt: new Date().toISOString() }) + '\\n');
+  spawnDaemonLikeProcess({
+    cliHomeDir: home,
+    statePaths,
+    internalServerUrl: String(process.env.HAPPIER_SERVER_URL || ''),
+    publicServerUrl: String(process.env.HAPPIER_WEBAPP_URL || ''),
+    distClosureFingerprint: process.env.HAPPIER_CLI_SUBPROCESS_DAEMON_DIST_CLOSURE_FINGERPRINT,
+  });
+  const readyDeadline = Date.now() + 5_000;
+  while (!statePaths.every((path) => existsSync(path)) && Date.now() < readyDeadline) {
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+  if (!statePaths.every((path) => existsSync(path))) {
+    console.error('daemon fixture failed to publish control state');
+    process.exit(2);
+  }
   process.exit(0);
 }
 if (sub === 'stop') {
   append('stop');
-  if (existsSync(statePath)) {
+  const existingStatePath = statePaths.find((path) => existsSync(path));
+  if (existingStatePath) {
     try {
-      const pid = Number(JSON.parse(readFileSync(statePath, 'utf8')).pid);
+      const pid = Number(JSON.parse(readFileSync(existingStatePath, 'utf8')).pid);
       if (Number.isFinite(pid) && pid > 1) {
-        try { process.kill(pid, 'SIGTERM'); } catch {}
+        killDetachedProcessGroup(pid);
       }
     } catch {}
   }
@@ -93,7 +111,7 @@ if (sub === 'stop') {
   process.exit(0);
 }
 if (sub === 'status') {
-  const running = existsSync(statePath);
+  const running = statePaths.some((path) => existsSync(path));
   ${includeRunningInStatusLog
     ? `append(${JSON.stringify(statusLogLine)} + String(running));`
     : `append(${JSON.stringify(statusLogLine)});`}
@@ -107,6 +125,10 @@ process.exit(0);
 export async function createStartableRuntimeSnapshotFixture(t, {
   stackName = 'runtime-prod',
   serverPort,
+  listenerDiscoveryMode = null,
+  serverComponent = 'happier-server-light',
+  dbProvider = serverComponent === 'happier-server' ? 'postgres' : 'sqlite',
+  runtimeMigration = 'success',
 } = {}) {
   const preserveFixture = (process.env.HAPPIER_TEST_PRESERVE_RUNTIME_FIXTURE ?? '').toString().trim() === '1';
   const fixture = await createTempFixture(t, {
@@ -123,13 +145,17 @@ export async function createStartableRuntimeSnapshotFixture(t, {
   const cliHomeDir = join(stackDir, 'cli');
   const runtimeDir = join(stackDir, 'runtime');
   const serverEnvCapturePath = join(stackDir, 'server.runtime-env.json');
+  const serverPidCapturePath = join(stackDir, 'server.pid.capture');
+  const listenerDiscoveryLogPath = join(stackDir, 'listener-discovery.log');
+  const runtimeServerEventLogPath = join(stackDir, 'runtime-server-events.log');
+  const daemonDistClosureFingerprint = '0123456789abcdef';
 
   await mkdir(cliHomeDir, { recursive: true });
   await mkdir(runtimeDir, { recursive: true });
 
   const serverScript = `
 import { createServer } from 'node:http';
-import { readFileSync, writeFileSync } from 'node:fs';
+import { appendFileSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 const port = Number(process.env.PORT || process.env.HAPPIER_SERVER_PORT || 0);
@@ -140,9 +166,14 @@ if (!Number.isFinite(port) || port <= 0) {
 const uiDir = String(process.env.HAPPIER_SERVER_UI_DIR || '').trim();
 const marker = String(process.env.HAPPIER_RUNTIME_SNAPSHOT_MARKER || 'runtime-snapshot');
 const envCapturePath = String(process.env.HAPPIER_RUNTIME_SERVER_ENV_CAPTURE_PATH || '').trim();
+const pidCapturePath = String(process.env.HAPPIER_TEST_SERVER_PID_CAPTURE_PATH || '').trim();
+const eventLogPath = String(process.env.HAPPIER_TEST_RUNTIME_SERVER_EVENT_LOG || '').trim();
+if (eventLogPath) appendFileSync(eventLogPath, 'server\\n', 'utf8');
 if (envCapturePath) {
   writeFileSync(envCapturePath, JSON.stringify({
     DATABASE_URL: process.env.DATABASE_URL ?? null,
+    HAPPIER_SERVER_FLAVOR: process.env.HAPPIER_SERVER_FLAVOR ?? null,
+    HAPPY_SERVER_FLAVOR: process.env.HAPPY_SERVER_FLAVOR ?? null,
     HAPPIER_SQLITE_AUTO_MIGRATE: process.env.HAPPIER_SQLITE_AUTO_MIGRATE ?? null,
     HAPPIER_SQLITE_MIGRATIONS_DIR: process.env.HAPPIER_SQLITE_MIGRATIONS_DIR ?? null,
     HAPPIER_SERVER_LIGHT_DATA_DIR: process.env.HAPPIER_SERVER_LIGHT_DATA_DIR ?? null,
@@ -150,13 +181,15 @@ if (envCapturePath) {
 }
 const server = createServer((req, res) => {
   const url = new URL(req.url || '/', 'http://127.0.0.1');
-  if (url.pathname === '/health') {
+  if (url.pathname === '/health' || url.pathname === '/ready') {
     res.writeHead(200, { 'content-type': 'application/json' });
-    res.end(JSON.stringify({ status: 'ok', marker }));
+    res.end(JSON.stringify({ service: 'happier-server', status: 'ok', marker }));
     return;
   }
   if (url.pathname === '/' || url.pathname === '/index.html') {
-    const html = readFileSync(join(uiDir, 'index.html'), 'utf8');
+    const html = uiDir
+      ? readFileSync(join(uiDir, 'index.html'), 'utf8')
+      : '<!doctype html><html><body>runtime server fixture</body></html>';
     res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
     res.end(html);
     return;
@@ -166,6 +199,7 @@ const server = createServer((req, res) => {
 });
 
 server.listen(port, '127.0.0.1', () => {
+  if (pidCapturePath) writeFileSync(pidCapturePath, String(process.pid) + '\\n', 'utf8');
   console.log('runtime-server-ready:' + port);
 });
 
@@ -188,6 +222,12 @@ process.on('SIGINT', shutdown);
     statusLogLine: 'status',
   });
 
+  await writeStubHappierCliFiles(root, {
+    packageJsonContent: '{}\n',
+    binHappierScript: cliScript.trimStart(),
+    distIndexScript: cliScript.trimStart(),
+  });
+
   const { snapshotDir } = await writeRuntimeSnapshotLayout({
     stackDir,
     snapshotId: 'snap-startable',
@@ -197,8 +237,8 @@ process.on('SIGINT', shutdown);
     createdAt: '2026-03-07T12:00:00.000Z',
     source: {
       repoDir: root,
-      serverComponent: 'happier-server-light',
-      dbProvider: 'sqlite',
+      serverComponent,
+      dbProvider,
       commitSha: 'fixture',
       dirtyHash: 'clean',
       sourceFingerprint: 'src-startable',
@@ -217,8 +257,18 @@ process.on('SIGINT', shutdown);
       artifactFingerprint: 'daemon-startable',
       nodeEntrypoint: 'cli/package-dist/index.mjs',
       nodeContent: cliPackageDistScript.trimStart(),
+      distClosureFingerprint: daemonDistClosureFingerprint,
     },
   });
+  if (['postgres', 'mysql', 'pglite'].includes(dbProvider) && runtimeMigration !== 'missing') {
+    const migrationScript = `#!/usr/bin/env node
+import { appendFileSync } from 'node:fs';
+appendFileSync(${JSON.stringify(runtimeServerEventLogPath)}, 'migration:' + process.cwd() + ':' + process.env.HAPPIER_DB_PROVIDER + ':' + process.env.DATABASE_URL + '\\n', 'utf8');
+`;
+    const migrationPath = join(snapshotDir, 'server', 'happier-server-migrate');
+    await writeFile(migrationPath, migrationScript, 'utf8');
+    await chmod(migrationPath, 0o755);
+  }
   const sqliteMigrationsDir = join(snapshotDir, 'server', 'prisma', 'sqlite', 'migrations', '20260101000000_fixture');
   await mkdir(sqliteMigrationsDir, { recursive: true });
   await writeFile(join(sqliteMigrationsDir, 'migration.sql'), '-- fixture migration\n', 'utf8');
@@ -234,7 +284,7 @@ process.on('SIGINT', shutdown);
     [
       `HAPPIER_STACK_STACK=${stackName}`,
       `HAPPIER_STACK_REPO_DIR=${root}`,
-      `HAPPIER_STACK_SERVER_COMPONENT=happier-server-light`,
+      `HAPPIER_STACK_SERVER_COMPONENT=${serverComponent}`,
       `HAPPIER_STACK_SERVER_PORT=${resolvedServerPort}`,
       `HAPPIER_STACK_CLI_HOME_DIR=${cliHomeDir}`,
       'HAPPIER_STACK_RUNTIME_MODE=require',
@@ -243,6 +293,12 @@ process.on('SIGINT', shutdown);
       'HAPPIER_STACK_SERVICE_MODE=0',
       'HAPPIER_RUNTIME_SNAPSHOT_MARKER=snap-startable',
       `HAPPIER_RUNTIME_SERVER_ENV_CAPTURE_PATH=${serverEnvCapturePath}`,
+      `HAPPIER_TEST_RUNTIME_SERVER_EVENT_LOG=${runtimeServerEventLogPath}`,
+      `HAPPIER_DB_PROVIDER=${dbProvider}`,
+      ...(serverComponent === 'happier-server' ? ['HAPPIER_STACK_MANAGED_INFRA=0'] : []),
+      ...(['postgres', 'mysql'].includes(dbProvider)
+        ? [`DATABASE_URL=${dbProvider}://runtime-fixture.invalid/happier`]
+        : []),
       '',
     ].join('\n'),
     'utf8',
@@ -267,6 +323,42 @@ process.on('SIGINT', shutdown);
   await writeFile(credentialPaths.legacyPath, 'dummy\n', 'utf8');
   await writeFile(join(cliHomeDir, 'settings.json'), JSON.stringify({ machineId: 'runtime-fixture-machine' }) + '\n', 'utf8');
 
+  let listenerDiscoveryEnv = {};
+  if (listenerDiscoveryMode) {
+    const binDir = join(root, 'listener-bin');
+    const lsofPath = join(binDir, 'lsof');
+    await mkdir(binDir, { recursive: true });
+    await writeFile(lsofPath, `#!/bin/sh
+group=""
+while [ "$#" -gt 0 ]; do
+  if [ "$1" = "-g" ]; then
+    shift
+    group="$1"
+  fi
+  shift
+done
+if [ ! -f "$HAPPIER_TEST_SERVER_PID_CAPTURE_PATH" ]; then
+  printf '%s\\n' 'empty' >> "$HAPPIER_TEST_LISTENER_DISCOVERY_LOG_PATH"
+  exit 1
+fi
+if [ "$HAPPIER_TEST_LISTENER_DISCOVERY_MODE" = "delayed-group-proof" ] && [ -n "$group" ]; then
+  printf 'group:%s\\n' "$group" >> "$HAPPIER_TEST_LISTENER_DISCOVERY_LOG_PATH"
+  sleep 0.3
+  sed -n '1p' "$HAPPIER_TEST_SERVER_PID_CAPTURE_PATH"
+  exit 0
+fi
+printf '%s\\n' 'inconclusive' >> "$HAPPIER_TEST_LISTENER_DISCOVERY_LOG_PATH"
+sleep 5
+`, 'utf8');
+    await chmod(lsofPath, 0o755);
+    listenerDiscoveryEnv = {
+      PATH: `${binDir}:${process.env.PATH ?? ''}`,
+      HAPPIER_TEST_LISTENER_DISCOVERY_MODE: listenerDiscoveryMode,
+      HAPPIER_TEST_LISTENER_DISCOVERY_LOG_PATH: listenerDiscoveryLogPath,
+      HAPPIER_TEST_SERVER_PID_CAPTURE_PATH: serverPidCapturePath,
+    };
+  }
+
   return {
     root,
     storageDir,
@@ -276,6 +368,11 @@ process.on('SIGINT', shutdown);
     cliHomeDir,
     serverPort: resolvedServerPort,
     serverEnvCapturePath,
+    serverPidCapturePath,
+    listenerDiscoveryLogPath,
+    runtimeServerEventLogPath,
+    listenerDiscoveryEnv,
+    daemonDistClosureFingerprint,
     baseUrl: `http://127.0.0.1:${resolvedServerPort}`,
   };
 }

package/scripts/testkit/runtime_snapshot_testkit.mjs

@@ -27,6 +27,9 @@ export async function createRuntimeSnapshotFixture(
     stackDir,
     snapshotId: 'snap-1',
     sourceFingerprint: 'src-1',
+    source: {
+      serverComponent: 'happier-server-light',
+    },
     writeCurrentMirror: true,
     web: {
       content: '<html></html>\n',

package/scripts/testkit/stack_happier_cli_command_testkit.mjs

@@ -24,6 +24,9 @@ export async function createStackHappierCliCommandFixture(
   const stackCliHome = join(storageDir, stackName, 'cli');
 
   await ensureMinimalMonorepoLayout(monoRoot);
+  await mkdir(join(monoRoot, 'apps', 'cli', 'node_modules'), { recursive: true });
+  await writeFile(join(monoRoot, 'apps', 'cli', 'node_modules', '.yarn-integrity'), 'ok\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'cli', 'yarn.lock'), '# fixture lock\n', 'utf-8');
   await writeStubHappierCliFiles(monoRoot, {
     distIndexScript,
     binHappierScript,
@@ -70,6 +73,7 @@ export async function createStackHappierCliCommandFixture(
       HAPPIER_STACK_STORAGE_DIR: storageDir,
       HAPPIER_STACK_WORKSPACE_DIR: workspaceDir,
       HAPPIER_STACK_CLI_ROOT_DISABLE: '1',
+      HAPPIER_STACK_SKIP_REFRESH_DEPS: '1',
     },
   };
 }

package/scripts/tools.mjs

@@ -18,6 +18,13 @@ const TOOL_SCRIPTS = {
   import: 'scripts/import.mjs',
   review: 'scripts/review.mjs',
   edison: 'scripts/edison.mjs',
+  'profile-processes': 'scripts/profile_processes.mjs',
+  profileprocesses: 'scripts/profile_processes.mjs',
+  profileProcesses: 'scripts/profile_processes.mjs',
+
+  'profile-mobile-scenario': 'scripts/profile_mobile_scenario.mjs',
+  profilemobilescenario: 'scripts/profile_mobile_scenario.mjs',
+  profileMobileScenario: 'scripts/profile_mobile_scenario.mjs',
 };
 
 async function main() {
@@ -42,7 +49,7 @@ async function main() {
   if (wantsHelp(argv, { flags }) || !cmd || cmd === 'help') {
     printResult({
       json,
-      data: { commands: ['setup-pr', 'review-pr', 'import', 'review', 'edison'] },
+      data: { commands: ['setup-pr', 'review-pr', 'import', 'review', 'edison', 'profile-processes', 'profile-mobile-scenario'] },
       text: [
         '[tools] usage:',
         '  hstack tools setup-pr --repo=<pr-url|number> [--dev|--start] [--json] [-- ...]',
@@ -50,6 +57,8 @@ async function main() {
         '  hstack tools import [--json]',
         '  hstack tools review [ui|cli|server|all] [--json]',
         '  hstack tools edison [--stack=<name>] -- <edison args...>',
+        '  hstack tools profile-processes --pid=<pid>|--command-match=<unique substring> [--duration=30s] [--interval=1s] [--stack-sample=10s] [--memory-map] [--json]',
+        '  hstack tools profile-mobile-scenario --scenario=<name> --udid=<ios-udid> [--execute-flow] [--profile-process] [--json]',
       ].join('\n'),
     });
     return;
@@ -61,6 +70,16 @@ async function main() {
 
   const idx = argv.indexOf(cmd);
   const forwarded = idx === -1 ? argv.slice(1) : [...argv.slice(0, idx), ...argv.slice(idx + 1)];
+  if (scriptRel === 'scripts/profile_processes.mjs') {
+    const { runProfileProcessesCli } = await import('./profile_processes.mjs');
+    await runProfileProcessesCli(forwarded);
+    return;
+  }
+  if (scriptRel === 'scripts/profile_mobile_scenario.mjs') {
+    const { runProfileMobileScenarioCli } = await import('./profile_mobile_scenario.mjs');
+    await runProfileMobileScenarioCli(forwarded);
+    return;
+  }
   await run(process.execPath, [join(rootDir, scriptRel), ...forwarded], { cwd: rootDir, env: process.env });
 }
 

package/scripts/tools_profile_processes_help.test.mjs

@@ -0,0 +1,131 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { getStackRootFromMeta, hstackBinPath, runNodeCapture } from './testkit/auth_testkit.mjs';
+
+test('hstack tools help includes profiling tools', async () => {
+  const rootDir = getStackRootFromMeta(import.meta.url);
+  const env = {
+    ...process.env,
+    HAPPIER_STACK_STACK: 'test-stack',
+    HAPPIER_STACK_ENV_FILE: join(rootDir, 'scripts', 'nonexistent-env'),
+  };
+
+  const res = await runNodeCapture([hstackBinPath(rootDir), 'tools', '--help'], { cwd: rootDir, env });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstderr:\n${res.stderr}\nstdout:\n${res.stdout}`);
+  assert.match(res.stdout, /profile-processes/, `expected tools help to include profile-processes\nstdout:\n${res.stdout}`);
+  assert.match(res.stdout, /profile-mobile-scenario/, `expected tools help to include profile-mobile-scenario\nstdout:\n${res.stdout}`);
+});
+
+test('hstack tools profile-processes samples the selected pid', async (t) => {
+  const rootDir = getStackRootFromMeta(import.meta.url);
+  const outputDir = await mkdtemp(join(tmpdir(), 'happier-tools-profile-processes-'));
+  const envFile = join(outputDir, 'env');
+  await writeFile(envFile, 'HAPPIER_STACK_STACK=test-stack\n', 'utf8');
+  t.after(async () => {
+    await rm(outputDir, { recursive: true, force: true }).catch(() => {});
+  });
+  const env = {
+    ...process.env,
+    HAPPIER_STACK_STACK: 'test-stack',
+    HAPPIER_STACK_ENV_FILE: envFile,
+  };
+
+  const res = await runNodeCapture(
+    [
+      hstackBinPath(rootDir),
+      'tools',
+      'profile-processes',
+      `--pid=${process.pid}`,
+      '--duration=1s',
+      '--interval=1s',
+      `--out-dir=${outputDir}`,
+      '--json',
+    ],
+    { cwd: rootDir, env },
+  );
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstderr:\n${res.stderr}\nstdout:\n${res.stdout}`);
+  const parsed = JSON.parse(res.stdout);
+  assert.equal(parsed.target.pid, process.pid);
+  assert.equal(parsed.summary.sampleCount, 2);
+  assert.match(parsed.artifacts.samples, /samples\.ndjson$/);
+  const samples = (await readFile(parsed.artifacts.samples, 'utf-8')).trim().split('\n');
+  assert.equal(samples.length, 2);
+});
+
+test('hstack tools profile-mobile-scenario lists canonical mobile scenarios', async (t) => {
+  const rootDir = getStackRootFromMeta(import.meta.url);
+  const fixtureDir = await mkdtemp(join(tmpdir(), 'happier-tools-mobile-profile-list-'));
+  const envFile = join(fixtureDir, 'env');
+  await writeFile(envFile, 'HAPPIER_STACK_STACK=test-stack\n', 'utf8');
+  t.after(async () => {
+    await rm(fixtureDir, { recursive: true, force: true }).catch(() => {});
+  });
+  const env = {
+    ...process.env,
+    HAPPIER_STACK_STACK: 'test-stack',
+    HAPPIER_STACK_ENV_FILE: envFile,
+  };
+
+  const res = await runNodeCapture([hstackBinPath(rootDir), 'tools', 'profile-mobile-scenario', '--list', '--json'], {
+    cwd: rootDir,
+    env,
+  });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstderr:\n${res.stderr}\nstdout:\n${res.stdout}`);
+  const parsed = JSON.parse(res.stdout);
+  const names = parsed.scenarios.map((scenario) => scenario.name);
+  assert.ok(names.includes('ios-session-list'));
+  assert.ok(names.includes('ios-streaming-session'));
+  assert.ok(names.includes('ios-cockpit-tabs'));
+  assert.ok(names.includes('ios-back-swipe'));
+});
+
+test('hstack tools profile-mobile-scenario generates current-device Argent flow and manifest', async (t) => {
+  const rootDir = getStackRootFromMeta(import.meta.url);
+  const projectRoot = await mkdtemp(join(tmpdir(), 'happier-tools-mobile-profile-project-'));
+  const outputDir = await mkdtemp(join(tmpdir(), 'happier-tools-mobile-profile-output-'));
+  const envFile = join(projectRoot, 'env');
+  await writeFile(envFile, 'HAPPIER_STACK_STACK=test-stack\n', 'utf8');
+  t.after(async () => {
+    await rm(projectRoot, { recursive: true, force: true }).catch(() => {});
+    await rm(outputDir, { recursive: true, force: true }).catch(() => {});
+  });
+  const env = {
+    ...process.env,
+    HAPPIER_STACK_STACK: 'test-stack',
+    HAPPIER_STACK_ENV_FILE: envFile,
+  };
+
+  const res = await runNodeCapture(
+    [
+      hstackBinPath(rootDir),
+      'tools',
+      'profile-mobile-scenario',
+      '--scenario=ios-root-tabs',
+      '--udid=SIM-CLI-123',
+      '--metro-port=18829',
+      `--project-root=${projectRoot}`,
+      `--out-dir=${outputDir}`,
+      '--json',
+    ],
+    { cwd: rootDir, env },
+  );
+
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstderr:\n${res.stderr}\nstdout:\n${res.stdout}`);
+  const parsed = JSON.parse(res.stdout);
+  assert.equal(parsed.scenario.name, 'ios-root-tabs');
+  assert.equal(parsed.executed, false);
+  assert.match(parsed.flow.file, /happier-ios-root-tabs-profile\.yaml$/);
+  assert.match(parsed.artifacts.manifest, /ios-root-tabs-mobile-profile-manifest\.json$/);
+
+  const flow = await readFile(parsed.flow.file, 'utf-8');
+  assert.match(flow, /SIM-CLI-123/);
+  assert.match(flow, /Open Settings root tab/);
+
+  const manifest = JSON.parse(await readFile(parsed.artifacts.manifest, 'utf-8'));
+  assert.equal(manifest.scenario.name, 'ios-root-tabs');
+  assert.equal(manifest.flow.file, parsed.flow.file);
+});