@happier-dev/stack 0.1.0 → 0.2.0-preview.1775370152.55749

package/scripts/remote_cmd.mjs

@@ -1,6 +1,8 @@
 import './utils/env/env.mjs';
 
-import { run, runCapture } from './utils/proc/proc.mjs';
+import { pathToFileURL } from 'node:url';
+import { getReleaseRingCatalogEntry, normalizePublicReleaseRingId } from '@happier-dev/release-runtime/releaseRings';
+import { run } from './utils/proc/proc.mjs';
 import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
 
 function takeFlagValue(args, name) {
@@ -38,54 +40,90 @@ function safeBashSingleQuote(s) {
   return `'${raw.replaceAll("'", `'\"'\"'`)}'`;
 }
 
-function parseJsonLinesBestEffort(stdout) {
-  const out = String(stdout ?? '');
-  const lines = out
-    .split(/\r?\n/)
-    .map((l) => l.trim())
-    .filter(Boolean);
-  for (const line of lines) {
-    try {
-      return JSON.parse(line);
-    } catch {
-      continue;
-    }
-  }
-  return null;
+function displayChannel(channel) {
+  const normalized = normalizePublicReleaseRingId(channel);
+  if (!normalized) return String(channel ?? '').trim() || 'stable';
+  return getReleaseRingCatalogEntry(normalized).publicLabel;
 }
 
-async function runSsh({ target, command }) {
-  await run('ssh', [target, 'bash', '-lc', safeBashSingleQuote(command)], { env: process.env });
+function assertPublicChannel(channel, source = '--channel') {
+  const normalized = normalizePublicReleaseRingId(channel);
+  if (!normalized) {
+    throw new Error(`[remote] invalid ${source} value: ${channel} (expected stable|preview|dev)`);
+  }
+  return normalized;
 }
 
-async function runSshJson({ target, command }) {
-  const out = await runCapture('ssh', [target, 'bash', '-lc', safeBashSingleQuote(command)], { env: process.env });
-  const parsed = parseJsonLinesBestEffort(out);
-  if (!parsed) {
-    throw new Error('Remote command did not return valid JSON');
+export async function runRemoteDaemonSetupWithDeps(argvRaw, deps = {}) {
+  const resolvedDeps = {
+    runLocalMachineBootstrap: async ({ args }) => {
+      await run('happier', args, { env: process.env });
+    },
+    ...deps,
+  };
+
+  const argv0 = argvRaw.slice();
+  const json = wantsJson(argv0);
+
+  let args = argv0.slice();
+  const ssh = takeFlagValue(args, '--ssh');
+  args = ssh.rest;
+  if (!ssh.value) {
+    process.stderr.write('Missing required flag: --ssh <user@host>\n');
+    process.exit(2);
   }
-  return parsed;
-}
 
-async function runLocalJson({ args }) {
-  const out = await runCapture('happier', args, { env: process.env });
-  const parsed = parseJsonLinesBestEffort(out);
-  if (!parsed) {
-    throw new Error('Local command did not return valid JSON');
+  const sshConfigFile = takeFlagValue(args, '--ssh-config-file');
+  args = sshConfigFile.rest;
+
+  const channel = assertPublicChannel(resolveChannel(argv0));
+
+  const service = resolveService(argv0);
+  if (service !== 'user' && service !== 'none') {
+    throw new Error(`[remote] invalid --service value: ${service} (expected user or none)`);
   }
-  return parsed;
+
+  const serverUrlFlag = takeFlagValue(args, '--server-url');
+  args = serverUrlFlag.rest;
+  const webappUrlFlag = takeFlagValue(args, '--webapp-url');
+  args = webappUrlFlag.rest;
+  const publicServerUrlFlag = takeFlagValue(args, '--public-server-url');
+  args = publicServerUrlFlag.rest;
+
+  await resolvedDeps.runLocalMachineBootstrap({
+    args: [
+      'machine',
+      'setup',
+      '--ssh',
+      ssh.value,
+      ...(channel === 'stable' ? [] : [`--channel=${channel}`]),
+      `--service-mode=${service}`,
+      ...(sshConfigFile.value ? [`--ssh-config-file=${sshConfigFile.value}`] : []),
+      ...(serverUrlFlag.value ? [`--server-url=${serverUrlFlag.value}`] : []),
+      ...(webappUrlFlag.value ? [`--webapp-url=${webappUrlFlag.value}`] : []),
+      ...(publicServerUrlFlag.value ? [`--public-server-url=${publicServerUrlFlag.value}`] : []),
+      ...(json ? ['--json'] : []),
+    ],
+  });
 }
 
 function usageText() {
   return [
     '[remote] usage:',
-    '  hstack remote daemon setup --ssh <user@host> [--preview|--stable] [--channel <stable|preview>]',
-    '    [--service <user|none>]',
+    '  hstack remote daemon setup --ssh <user@host> [--preview|--dev|--stable] [--channel <stable|preview|dev>]',
+    '    [--service <user|none>] [--ssh-config-file <path>]',
     '    [--server-url=<url>] [--webapp-url=<url>] [--public-server-url=<url>]',
     '    [--json]',
     '',
-    '  hstack remote server setup --ssh <user@host> [--preview|--stable] [--channel <stable|preview>]',
+    '  hstack remote server setup --ssh <user@host> [--preview|--dev|--stable] [--channel <stable|preview|dev>]',
+    '    [--mode <user|system>]',
+    '    [--self-host-server-binary <path>]',
+    '    [--env KEY=VALUE]...',
+    '    [--json]',
+    '',
+    '  hstack remote relay setup --ssh <user@host> [--preview|--dev|--stable] [--channel <stable|preview|dev>]',
     '    [--mode <user|system>]',
+    '    [--self-host-server-binary <path>]',
     '    [--env KEY=VALUE]...',
     '    [--json]',
     '',
@@ -99,16 +137,17 @@ function usageText() {
 
 function resolveChannel(argv) {
   if (argv.includes('--preview')) return 'preview';
+  if (argv.includes('--dev')) return 'publicdev';
   if (argv.includes('--stable')) return 'stable';
   const picked = argv.find((a) => a === '--channel' || a.startsWith('--channel='));
   if (!picked) return 'stable';
   if (picked === '--channel') {
     const idx = argv.indexOf('--channel');
     const v = String(argv[idx + 1] ?? '').trim();
-    return v || 'stable';
+    return normalizePublicReleaseRingId(v) || v || 'stable';
   }
   const v = String(picked.slice('--channel='.length)).trim();
-  return v || 'stable';
+  return normalizePublicReleaseRingId(v) || v || 'stable';
 }
 
 function resolveService(argv) {
@@ -161,105 +200,7 @@ function collectEnvValues(argv) {
 }
 
 async function runRemoteDaemonSetup(argvRaw) {
-  const argv0 = argvRaw.slice();
-  const json = wantsJson(argv0);
-
-  let args = argv0.slice();
-  const ssh = takeFlagValue(args, '--ssh');
-  args = ssh.rest;
-  if (!ssh.value) {
-    process.stderr.write('Missing required flag: --ssh <user@host>\n');
-    process.exit(2);
-  }
-
-  const channel = resolveChannel(argv0);
-  if (channel !== 'stable' && channel !== 'preview') {
-    throw new Error(`[remote] invalid --channel value: ${channel}`);
-  }
-
-  const service = resolveService(argv0);
-  if (service !== 'user' && service !== 'none') {
-    throw new Error(`[remote] invalid --service value: ${service} (expected user or none)`);
-  }
-
-  const serverUrlFlag = takeFlagValue(args, '--server-url');
-  args = serverUrlFlag.rest;
-  const webappUrlFlag = takeFlagValue(args, '--webapp-url');
-  args = webappUrlFlag.rest;
-  const publicServerUrlFlag = takeFlagValue(args, '--public-server-url');
-  args = publicServerUrlFlag.rest;
-
-  const serverFlags = {
-    serverUrl: serverUrlFlag.value,
-    webappUrl: webappUrlFlag.value,
-    publicServerUrl: publicServerUrlFlag.value,
-    localArgs: [
-      ...(serverUrlFlag.value ? [`--server-url=${serverUrlFlag.value}`] : []),
-      ...(webappUrlFlag.value ? [`--webapp-url=${webappUrlFlag.value}`] : []),
-      ...(publicServerUrlFlag.value ? [`--public-server-url=${publicServerUrlFlag.value}`] : []),
-    ],
-  };
-
-  const installUrl = 'https://happier.dev/install';
-  const remoteBin = '$HOME/.happier/bin/happier';
-
-  // Always disable auto-service setup in the installer so this command controls service behavior.
-  const installCmd = [
-    `curl -fsSL ${installUrl} |`,
-    `HAPPIER_CHANNEL=${channel} HAPPIER_WITH_DAEMON=0 HAPPIER_NONINTERACTIVE=1 bash`,
-  ].join(' ');
-
-  await runSsh({ target: ssh.value, command: installCmd });
-
-  if (serverFlags.serverUrl) {
-    const serverUrl = safeBashSingleQuote(serverFlags.serverUrl);
-    const webappUrl = safeBashSingleQuote(serverFlags.webappUrl || serverFlags.serverUrl);
-    // Persist server targeting on the remote host so future `happier daemon start` uses the same server.
-    await runSsh({
-      target: ssh.value,
-      command: `${remoteBin} server set --server-url ${serverUrl} --webapp-url ${webappUrl} --json`,
-    });
-  }
-
-  const request = await runSshJson({ target: ssh.value, command: `${remoteBin} auth request --json` });
-  const publicKey = typeof request?.publicKey === 'string' ? request.publicKey : '';
-  if (!publicKey) {
-    throw new Error('Remote auth request did not include "publicKey"');
-  }
-
-  await runLocalJson({
-    args: [...serverFlags.localArgs, 'auth', 'approve', '--public-key', publicKey, '--json'],
-  });
-
-  await runSshJson({
-    target: ssh.value,
-    command: `${remoteBin} auth wait --public-key ${safeBashSingleQuote(publicKey)} --json`,
-  });
-
-  if (service === 'user') {
-    const envParts = [];
-    if (serverFlags.serverUrl) envParts.push(`HAPPIER_DAEMON_SERVICE_SERVER_URL=${safeBashSingleQuote(serverFlags.serverUrl)}`);
-    if (serverFlags.webappUrl) envParts.push(`HAPPIER_DAEMON_SERVICE_WEBAPP_URL=${safeBashSingleQuote(serverFlags.webappUrl)}`);
-    if (serverFlags.publicServerUrl) envParts.push(`HAPPIER_DAEMON_SERVICE_PUBLIC_SERVER_URL=${safeBashSingleQuote(serverFlags.publicServerUrl)}`);
-    const envPrefix = envParts.length ? `${envParts.join(' ')} ` : '';
-
-    await runSsh({ target: ssh.value, command: `${envPrefix}${remoteBin} daemon service install` });
-    await runSsh({ target: ssh.value, command: `${envPrefix}${remoteBin} daemon service start` });
-  }
-
-  printResult({
-    json,
-    data: { ok: true, ssh: ssh.value, channel, service, publicKey },
-    text: json
-      ? null
-      : [
-          '✓ Remote daemon setup complete',
-          `- ssh: ${ssh.value}`,
-          `- channel: ${channel}`,
-          `- service: ${service}`,
-          `- publicKey: ${publicKey}`,
-        ].join('\n'),
-  });
+  await runRemoteDaemonSetupWithDeps(argvRaw);
 }
 
 async function runRemoteServerSetup(argvRaw) {
@@ -274,57 +215,34 @@ async function runRemoteServerSetup(argvRaw) {
     process.exit(2);
   }
 
-  const channel = resolveChannel(argv0);
-  if (channel !== 'stable' && channel !== 'preview') {
-    throw new Error(`[remote] invalid --channel value: ${channel}`);
-  }
+  const channel = assertPublicChannel(resolveChannel(argv0));
 
   const mode = resolveMode(argv0);
   if (mode !== 'user' && mode !== 'system') {
     throw new Error(`[remote] invalid --mode value: ${mode} (expected user or system)`);
   }
 
-  const envValues = collectEnvValues(argv0);
-
-  const installUrl = 'https://happier.dev/install';
-  const remoteHstack = '$HOME/.happier/bin/hstack';
+  const selfHostServerBinaryFlag = takeFlagValue(args, '--self-host-server-binary');
+  args = selfHostServerBinaryFlag.rest;
 
-  // Always disable auto-service setup in the installer so this command controls remote service behavior.
-  const installCmd = [
-    `curl -fsSL ${installUrl} |`,
-    `HAPPIER_CHANNEL=${channel} HAPPIER_WITH_DAEMON=0 HAPPIER_NONINTERACTIVE=1 bash`,
-  ].join(' ');
-
-  await runSsh({ target: ssh.value, command: installCmd });
-
-  const envArgs = envValues.map((value) => `--env ${safeBashSingleQuote(value)}`).join(' ');
-  const baseSelfHostCmd = [
-    remoteHstack,
-    'self-host',
-    'install',
-    `--channel=${channel}`,
-    `--mode=${mode}`,
-    '--without-cli',
-    '--non-interactive',
-    '--json',
-  ].join(' ');
-  const selfHostCmd = `${mode === 'system' ? 'sudo -E ' : ''}${baseSelfHostCmd}${envArgs ? ` ${envArgs}` : ''}`;
-
-  await runSsh({ target: ssh.value, command: selfHostCmd });
+  const envValues = collectEnvValues(argv0);
 
-  printResult({
-    json,
-    data: { ok: true, ssh: ssh.value, channel, mode, env: envValues },
-    text: json
-      ? null
-      : [
-          '✓ Remote server setup complete',
-          `- ssh: ${ssh.value}`,
-          `- channel: ${channel}`,
-          `- mode: ${mode}`,
-          `- env: ${envValues.length ? envValues.join(', ') : '(none)'}`,
-        ].join('\n'),
-  });
+  await run(
+    'happier',
+    [
+      'relay',
+      'host',
+      'install',
+      '--ssh',
+      ssh.value,
+      `--channel=${channel === 'publicdev' ? 'dev' : channel}`,
+      `--mode=${mode}`,
+      ...(selfHostServerBinaryFlag.value ? ['--self-host-server-binary', selfHostServerBinaryFlag.value] : []),
+      ...envValues.flatMap((value) => ['--env', value]),
+      ...(json ? ['--json'] : []),
+    ],
+    { env: process.env },
+  );
 }
 
 async function main() {
@@ -346,6 +264,10 @@ async function main() {
     await runRemoteServerSetup(argvRaw);
     return;
   }
+  if (top === 'relay' && sub === 'setup') {
+    await runRemoteServerSetup(argvRaw);
+    return;
+  }
 
   printResult({
     json: wantsJson(argvRaw),
@@ -355,8 +277,10 @@ async function main() {
   process.exit(2);
 }
 
-main().catch((error) => {
-  const msg = error instanceof Error ? error.message : String(error);
-  process.stderr.write(`${msg}\n`);
-  process.exit(1);
-});
+if (import.meta.url === pathToFileURL(process.argv[1] || '').href) {
+  main().catch((error) => {
+    const msg = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${msg}\n`);
+    process.exit(1);
+  });
+}

package/scripts/remote_cmd.test.mjs

@@ -0,0 +1,54 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { runRemoteDaemonSetupWithDeps } from './remote_cmd.mjs';
+
+test('remote daemon setup delegates to happier machine setup with relay targeting and user service defaults', async () => {
+  const invocations = [];
+
+  await runRemoteDaemonSetupWithDeps(
+    ['daemon', 'setup', '--ssh', 'dev@example.test', '--ssh-config-file', '/tmp/lima-ssh.config', '--server-url', 'https://relay.example.test', '--webapp-url', 'https://app.example.test', '--json'],
+    {
+      runLocalMachineBootstrap: async (params) => {
+        invocations.push(params);
+      },
+    },
+  );
+
+  assert.equal(invocations.length, 1);
+  assert.deepEqual(invocations[0].args, [
+    'machine',
+    'setup',
+    '--ssh',
+    'dev@example.test',
+    '--service-mode=user',
+    '--ssh-config-file=/tmp/lima-ssh.config',
+    '--server-url=https://relay.example.test',
+    '--webapp-url=https://app.example.test',
+    '--json',
+  ]);
+});
+
+test('remote daemon setup forwards service none and release channel flags to happier machine setup', async () => {
+  const invocations = [];
+
+  await runRemoteDaemonSetupWithDeps(
+    ['daemon', 'setup', '--ssh', 'dev@example.test', '--ssh-config-file=/tmp/lima-ssh.config', '--service', 'none', '--preview'],
+    {
+      runLocalMachineBootstrap: async (params) => {
+        invocations.push(params);
+      },
+    },
+  );
+
+  assert.equal(invocations.length, 1);
+  assert.deepEqual(invocations[0].args, [
+    'machine',
+    'setup',
+    '--ssh',
+    'dev@example.test',
+    '--channel=preview',
+    '--service-mode=none',
+    '--ssh-config-file=/tmp/lima-ssh.config',
+  ]);
+});

package/scripts/repo_cli_activate.test.mjs

@@ -1,22 +1,10 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { spawn } from 'node:child_process';
 import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-
-function runNode(args, { cwd, env }) {
-  return new Promise((resolvePromise, reject) => {
-    const proc = spawn(process.execPath, args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
-    let stdout = '';
-    let stderr = '';
-    proc.stdout.on('data', (d) => (stdout += String(d)));
-    proc.stderr.on('data', (d) => (stderr += String(d)));
-    proc.on('error', reject);
-    proc.on('exit', (code, signal) => resolvePromise({ code: code ?? (signal ? 1 : 0), signal, stdout, stderr }));
-  });
-}
+import { runNodeCapture as runNode } from './testkit/core/run_node_capture.mjs';
 
 test('repo cli activate configures init with cli-root-dir pointing at this checkout', async () => {
   const scriptsDir = dirname(fileURLToPath(import.meta.url));
@@ -51,4 +39,3 @@ test('repo cli activate configures init with cli-root-dir pointing at this check
     rmSync(canonicalHomeDir, { recursive: true, force: true });
   }
 });
-

package/scripts/repo_local.mjs

@@ -42,12 +42,14 @@ function usage() {
     '  node apps/stack/scripts/repo_local.mjs dev',
     '  node apps/stack/scripts/repo_local.mjs start --restart',
     '  node apps/stack/scripts/repo_local.mjs tui',
+    '  node apps/stack/scripts/repo_local.mjs tui --tauri',
     '  node apps/stack/scripts/repo_local.mjs tui stack dev exp1',
     '',
     'notes:',
     '  - Forces using this repo checkout (no re-exec to global hstack install).',
     '  - Defaults to an isolated per-checkout stack (prevents collisions with your main stack).',
     '  - `tui` defaults to `tui dev` when no command is provided.',
+    '  - `tui --tauri` adds a Tauri dev pane and keeps the stack UI off in that run.',
     '  - `stop` maps to `stack stop <repo-stack>` for convenience.',
     '  - Use --dry-run to print the resolved invocation as JSON.',
   ].join('\n');
@@ -273,6 +275,7 @@ async function main() {
       argv = ['tui', 'dev', ...forwarded];
     }
   }
+  const wantsTuiMobile = argv[0] === 'tui' && argv.some((arg) => String(arg ?? '').trim() === '--mobile' || String(arg ?? '').trim() === '--with-mobile');
 
   const scriptsDir = dirname(fileURLToPath(import.meta.url)); // <repo>/apps/stack/scripts
   const repoRoot = dirname(dirname(dirname(scriptsDir))); // <repo>
@@ -316,15 +319,16 @@ async function main() {
   }
 
   // Convenience:
-  // `yarn mobile:install` should install a Release iOS build for the repo-local stack without requiring users
+  // `yarn mobile:install` should install a local iOS build for the repo-local stack without requiring users
   // to know the generated stack name, and should run the full stack install flow (prebuild, identity, etc).
   if (subcommand === 'mobile:install') {
     const forwarded = argv.slice(1);
+    const isDevelopmentInstall = forwarded.some((a) => String(a ?? '').trim() === '--app-env=development');
     const hasName = forwarded.some((a) => {
       const s = String(a ?? '').trim();
       return s === '--name' || s.startsWith('--name=') || s === '--app-name' || s.startsWith('--app-name=');
     });
-    const defaultNameArg = hasName ? [] : ['--name=Happier (Local)'];
+    const defaultNameArg = hasName ? [] : [isDevelopmentInstall ? '--name=Happier Dev (Local)' : '--name=Happier (Local)'];
     argv = ['stack', 'mobile:install', stacklessName, ...defaultNameArg, ...forwarded];
   }
 
@@ -376,6 +380,7 @@ async function main() {
           HAPPIER_STACK_EXPO_DEV_PORT_RANGE: (process.env.HAPPIER_STACK_EXPO_DEV_PORT_RANGE ?? '2000').toString(),
           // Make Expo's Metro use stable (stack-scoped) port strategy.
           HAPPIER_STACK_EXPO_DEV_PORT_STRATEGY: (process.env.HAPPIER_STACK_EXPO_DEV_PORT_STRATEGY ?? 'stable').toString(),
+          ...(wantsTuiMobile ? { HAPPIER_STACK_CLI_BUILD_MODE: 'always' } : {}),
           ...(runtimeServerPort &&
           !existingPinnedServerPort &&
           isPortWithinRange(
@@ -501,6 +506,7 @@ async function main() {
             HAPPIER_STACK_SERVER_PORT: effectiveEnv.HAPPIER_STACK_SERVER_PORT,
             HAPPIER_STACK_ENV_FILE: effectiveEnv.HAPPIER_STACK_ENV_FILE,
             HAPPIER_STACK_CLI_HOME_DIR: effectiveEnv.HAPPIER_STACK_CLI_HOME_DIR,
+            HAPPIER_STACK_CLI_BUILD_MODE: effectiveEnv.HAPPIER_STACK_CLI_BUILD_MODE,
             HAPPIER_STACK_LOG_TEE_DIR: effectiveEnv.HAPPIER_STACK_LOG_TEE_DIR,
             HAPPIER_ACTIVE_SERVER_ID: effectiveEnv.HAPPIER_ACTIVE_SERVER_ID,
             HAPPIER_STACK_INVOKED_CWD: effectiveEnv.HAPPIER_STACK_INVOKED_CWD,

package/scripts/repo_local_wrapper.test.mjs

@@ -1,28 +1,25 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { dirname, join } from 'node:path';
-import { spawn } from 'node:child_process';
 import { createServer } from 'node:net';
 import { chmodSync, mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 
+import { runNodeCapture as runNode } from './testkit/core/run_node_capture.mjs';
 import { resolveStablePortStart } from './utils/expo/metro_ports.mjs';
 
-function runNode(args, { cwd, env }) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn(process.execPath, args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
-    let stdout = '';
-    let stderr = '';
-    proc.stdout.on('data', (d) => (stdout += String(d)));
-    proc.stderr.on('data', (d) => (stderr += String(d)));
-    proc.on('error', reject);
-    proc.on('exit', (code, signal) => resolve({ code: code ?? (signal ? 1 : 0), signal, stdout, stderr }));
-  });
-}
-
 async function listenOnPort(port) {
-  const srv = createServer(() => {});
+  const srv = createServer((socket) => {
+    // Tests use this only as a port reservation primitive. If something external
+    // (e.g. a browser tab) connects, immediately close the socket so server.close()
+    // cannot hang waiting for long-lived connections to drain.
+    try {
+      socket.destroy();
+    } catch {
+      // ignore
+    }
+  });
   await new Promise((resolve, reject) => {
     srv.once('error', reject);
     srv.listen({ host: '127.0.0.1', port }, () => resolve());
@@ -151,6 +148,28 @@ test('repo-local wrapper preserves flag-only tui args', async () => {
   assert.equal(data.args[2], '--json');
 });
 
+test('repo-local wrapper preserves explicit tui tauri flags', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const packageRoot = dirname(scriptsDir); // apps/stack
+  const repoRoot = dirname(dirname(packageRoot)); // repo root
+
+  const res = await runNode(
+    [join(packageRoot, 'scripts', 'repo_local.mjs'), 'tui', '--tauri', '--mobile', '--dry-run'],
+    {
+      cwd: repoRoot,
+      env: process.env,
+    }
+  );
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const data = JSON.parse(res.stdout);
+  assert.equal(data.ok, true);
+  assert.equal(data.args[1], 'tui');
+  assert.equal(data.args[2], '--tauri');
+  assert.equal(data.args[3], '--mobile');
+  assert.equal(data.env.HAPPIER_STACK_CLI_BUILD_MODE, 'always');
+});
+
 test('repo-local wrapper forwards --help when a subcommand is provided', async () => {
   const scriptsDir = dirname(fileURLToPath(import.meta.url));
   const packageRoot = dirname(scriptsDir); // apps/stack
@@ -219,6 +238,27 @@ test('repo-local wrapper maps `mobile:install` to stack mobile:install for the r
   );
 });
 
+test('repo-local wrapper uses a development-friendly default name for `mobile:install --app-env=development`', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const packageRoot = dirname(scriptsDir);
+  const repoRoot = dirname(dirname(packageRoot));
+
+  const res = await runNode(
+    [join(packageRoot, 'scripts', 'repo_local.mjs'), 'mobile:install', '--app-env=development', '--dry-run'],
+    {
+      cwd: repoRoot,
+      env: process.env,
+    }
+  );
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const data = JSON.parse(res.stdout);
+  assert.ok(
+    data.args.includes('--name=Happier Dev (Local)'),
+    `expected development install to default to a development-friendly app name:\n${JSON.stringify(data.args, null, 2)}`
+  );
+});
+
 test('repo-local wrapper auto-installs deps when node_modules are missing', async () => {
   const scriptsDir = dirname(fileURLToPath(import.meta.url));
   const packageRoot = dirname(scriptsDir); // apps/stack
@@ -428,6 +468,7 @@ test('repo-local wrapper persists a stable pinned server port when none is prese
             HAPPIER_STACK_STORAGE_DIR: stacksRoot,
             HAPPIER_STACK_SERVER_PORT_BASE: String(reserved.base),
             HAPPIER_STACK_SERVER_PORT_RANGE: String(reserved.range),
+            HAPPIER_STACK_REPO_LOCAL_AUTO_INSTALL: '0',
             HAPPIER_STACK_REPO_LOCAL_PREFLIGHT_ONLY: '1',
           },
         }