happy-stacks 0.3.0 → 0.5.0

package/scripts/utils/git/git.mjs

@@ -0,0 +1,67 @@
+import { runCapture } from '../proc/proc.mjs';
+
+export async function gitCapture({ cwd, args }) {
+  return String(await runCapture('git', args, { cwd }));
+}
+
+export async function gitOk({ cwd, args }) {
+  try {
+    await runCapture('git', args, { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function normalizeRemoteName({ cwd, remote }) {
+  const want = String(remote ?? '').trim();
+  if (!want) return want;
+
+  if (await gitOk({ cwd, args: ['remote', 'get-url', want] })) return want;
+
+  // Treat origin/fork as interchangeable if one exists.
+  if (want === 'origin' && (await gitOk({ cwd, args: ['remote', 'get-url', 'fork'] }))) return 'fork';
+  if (want === 'fork' && (await gitOk({ cwd, args: ['remote', 'get-url', 'origin'] }))) return 'origin';
+
+  return want;
+}
+
+export async function resolveRemoteDefaultBranch({ cwd, remote }) {
+  const r = String(remote ?? '').trim();
+  if (!r) return 'main';
+
+  // Prefer refs/remotes/<remote>/HEAD when available.
+  try {
+    const headRef = (await gitCapture({ cwd, args: ['symbolic-ref', '-q', '--short', `refs/remotes/${r}/HEAD`] })).trim();
+    if (headRef.startsWith(`${r}/`)) {
+      return headRef.slice(r.length + 1);
+    }
+  } catch {
+    // ignore
+  }
+
+  // Fallback: parse `git remote show` output.
+  try {
+    const out = await gitCapture({ cwd, args: ['remote', 'show', r] });
+    for (const line of out.split('\n')) {
+      const m = line.match(/^\s*HEAD branch:\s*(.+)\s*$/);
+      if (m?.[1]) return m[1].trim();
+    }
+  } catch {
+    // ignore
+  }
+
+  return 'main';
+}
+
+export async function ensureRemoteRefAvailable({ cwd, remote, branch }) {
+  const r = String(remote ?? '').trim();
+  const b = String(branch ?? '').trim();
+  if (!r || !b) return false;
+  const ref = `refs/remotes/${r}/${b}`;
+  if (await gitOk({ cwd, args: ['show-ref', '--verify', '--quiet', ref] })) return true;
+  // Best-effort fetch of the default branch.
+  await gitCapture({ cwd, args: ['fetch', '--quiet', r, b] }).catch(() => '');
+  return await gitOk({ cwd, args: ['show-ref', '--verify', '--quiet', ref] });
+}
+

package/scripts/utils/git/worktrees.mjs

@@ -1,6 +1,12 @@
+import { existsSync } from 'node:fs';
 import { readdir } from 'node:fs/promises';
-import { isAbsolute, join, resolve } from 'node:path';
-import { getComponentsDir } from '../paths/paths.mjs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import {
+  coerceHappyMonorepoRootFromPath,
+  getComponentRepoDir,
+  getComponentsDir,
+  happyMonorepoSubdirForComponent,
+} from '../paths/paths.mjs';
 import { pathExists } from '../fs/fs.mjs';
 import { run, runCapture } from '../proc/proc.mjs';
 
@@ -15,31 +21,55 @@ export function parseGithubOwner(remoteUrl) {
   return m?.groups?.owner ?? null;
 }
 
-export function getWorktreesRoot(rootDir) {
-  return join(getComponentsDir(rootDir), '.worktrees');
+export function getWorktreesRoot(rootDir, env = process.env) {
+  return join(getComponentsDir(rootDir, env), '.worktrees');
 }
 
-export function componentRepoDir(rootDir, component) {
-  return join(getComponentsDir(rootDir), component);
+export function componentRepoDir(rootDir, component, env = process.env) {
+  return getComponentRepoDir(rootDir, component, env);
 }
 
-export function isComponentWorktreePath({ rootDir, component, dir }) {
+function worktreeRepoKeyForComponent({ rootDir, component, env = process.env }) {
+  const c = String(component ?? '').trim();
+  const repoDir = componentRepoDir(rootDir, c, env);
+  const mono = coerceHappyMonorepoRootFromPath(repoDir);
+  // In monorepo mode, all worktrees live under `.worktrees/happy/` regardless of which
+  // package (expo-app/cli/server) the user is operating on.
+  return mono ? 'happy' : c;
+}
+
+export function isComponentWorktreePath({ rootDir, component, dir, env = process.env }) {
   const raw = String(dir ?? '').trim();
   if (!raw) return false;
   const abs = resolve(raw);
-  const root = resolve(join(getWorktreesRoot(rootDir), component)) + '/';
+  const key = worktreeRepoKeyForComponent({ rootDir, component, env });
+  const root = resolve(join(getWorktreesRoot(rootDir, env), key)) + '/';
   return abs.startsWith(root);
 }
 
-export function worktreeSpecFromDir({ rootDir, component, dir }) {
+export function worktreeSpecFromDir({ rootDir, component, dir, env = process.env }) {
   const raw = String(dir ?? '').trim();
   if (!raw) return null;
-  if (!isComponentWorktreePath({ rootDir, component, dir: raw })) return null;
+  if (!isComponentWorktreePath({ rootDir, component, dir: raw, env })) return null;
   const abs = resolve(raw);
-  const root = resolve(join(getWorktreesRoot(rootDir), component)) + '/';
-  const rel = abs.slice(root.length).split('/').filter(Boolean);
+  const key = worktreeRepoKeyForComponent({ rootDir, component, env });
+  const base = resolve(join(getWorktreesRoot(rootDir, env), key));
+
+  // Normalize to the actual worktree root directory (the one containing `.git`) so
+  // package subdirectories like `.../cli` don't corrupt the computed spec.
+  let cur = abs;
+  while (cur && cur !== base && cur !== dirname(cur)) {
+    if (existsSync(join(cur, '.git'))) {
+      break;
+    }
+    cur = dirname(cur);
+  }
+  if (!cur || cur === base || cur === dirname(cur)) return null;
+
+  const root = base + '/';
+  if (!cur.startsWith(root)) return null;
+  const rel = cur.slice(root.length).split('/').filter(Boolean);
   if (rel.length < 2) return null;
-  // rel = [owner, ...branchParts]
   return rel.join('/');
 }
 
@@ -69,30 +99,45 @@ export async function createWorktreeFromBaseWorktree({
   baseWorktreeSpec,
   remoteName = 'upstream',
   depsMode = '',
+  env = process.env,
 }) {
   const args = ['wt', 'new', component, slug, `--remote=${remoteName}`, `--base-worktree=${baseWorktreeSpec}`];
   if (depsMode) args.push(`--deps=${depsMode}`);
-  await run(process.execPath, [join(rootDir, 'bin', 'happys.mjs'), ...args], { cwd: rootDir });
+  await run(process.execPath, [join(rootDir, 'bin', 'happys.mjs'), ...args], { cwd: rootDir, env });
 
-  const repoDir = componentRepoDir(rootDir, component);
+  const repoDir = componentRepoDir(rootDir, component, env);
   const owner = await getRemoteOwner({ repoDir, remoteName });
-  return join(getWorktreesRoot(rootDir), component, owner, ...slug.split('/'));
+  const key = worktreeRepoKeyForComponent({ rootDir, component, env });
+  const wtRoot = join(getWorktreesRoot(rootDir, env), key, owner, ...slug.split('/'));
+  const sub = happyMonorepoSubdirForComponent(component);
+  const monoRoot = sub ? coerceHappyMonorepoRootFromPath(wtRoot) : null;
+  return sub && monoRoot ? join(monoRoot, sub) : wtRoot;
 }
 
-export function resolveComponentSpecToDir({ rootDir, component, spec }) {
+export function resolveComponentSpecToDir({ rootDir, component, spec, env = process.env }) {
   const raw = (spec ?? '').trim();
   if (!raw || raw === 'default') {
     return null;
   }
   if (isAbsolute(raw)) {
+    const monoRoot = coerceHappyMonorepoRootFromPath(raw);
+    const sub = happyMonorepoSubdirForComponent(component);
+    if (monoRoot && sub) {
+      return join(monoRoot, sub);
+    }
     return raw;
   }
-  // Treat as <owner>/<branch...> under components/.worktrees/<component>/...
-  return join(getWorktreesRoot(rootDir), component, ...raw.split('/'));
+  // Treat as <owner>/<branch...> under components/.worktrees/<repoKey>/...
+  const key = worktreeRepoKeyForComponent({ rootDir, component, env });
+  const wtRoot = join(getWorktreesRoot(rootDir, env), key, ...raw.split('/'));
+  const sub = happyMonorepoSubdirForComponent(component);
+  const monoRoot = sub ? coerceHappyMonorepoRootFromPath(wtRoot) : null;
+  return sub && monoRoot ? join(monoRoot, sub) : wtRoot;
 }
 
-export async function listWorktreeSpecs({ rootDir, component }) {
-  const dir = join(getWorktreesRoot(rootDir), component);
+export async function listWorktreeSpecs({ rootDir, component, env = process.env }) {
+  const key = worktreeRepoKeyForComponent({ rootDir, component, env });
+  const dir = join(getWorktreesRoot(rootDir, env), key);
   const specs = [];
   try {
     const walk = async (d, prefixParts) => {
@@ -103,6 +148,9 @@ export async function listWorktreeSpecs({ rootDir, component }) {
         const nextPrefix = [...prefixParts, e.name];
         if (await pathExists(join(p, '.git'))) {
           specs.push(nextPrefix.join('/'));
+          // IMPORTANT: do not recurse into worktree roots (they contain full repos and can be huge).
+          // Worktrees are leaf nodes for our purposes.
+          continue;
         }
         await walk(p, nextPrefix);
       }
@@ -125,10 +173,17 @@ export async function getRemoteOwner({ repoDir, remoteName = 'upstream' }) {
   return owner;
 }
 
-export async function createWorktree({ rootDir, component, slug, remoteName = 'upstream' }) {
+export async function createWorktree({ rootDir, component, slug, remoteName = 'upstream', env = process.env }) {
   // Create without modifying env.local (unless caller passes --use elsewhere).
-  await run(process.execPath, [join(rootDir, 'bin', 'happys.mjs'), 'wt', 'new', component, slug, `--remote=${remoteName}`], { cwd: rootDir });
-  const repoDir = componentRepoDir(rootDir, component);
+  await run(process.execPath, [join(rootDir, 'bin', 'happys.mjs'), 'wt', 'new', component, slug, `--remote=${remoteName}`], {
+    cwd: rootDir,
+    env,
+  });
+  const repoDir = componentRepoDir(rootDir, component, env);
   const owner = await getRemoteOwner({ repoDir, remoteName });
-  return join(getWorktreesRoot(rootDir), component, owner, ...slug.split('/'));
+  const key = worktreeRepoKeyForComponent({ rootDir, component, env });
+  const wtRoot = join(getWorktreesRoot(rootDir, env), key, owner, ...slug.split('/'));
+  const sub = happyMonorepoSubdirForComponent(component);
+  const monoRoot = sub ? coerceHappyMonorepoRootFromPath(wtRoot) : null;
+  return sub && monoRoot ? join(monoRoot, sub) : wtRoot;
 }

package/scripts/utils/git/worktrees_monorepo.test.mjs

@@ -0,0 +1,54 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { worktreeSpecFromDir } from './worktrees.mjs';
+
+async function withTempRoot(t) {
+  const dir = await mkdtemp(join(tmpdir(), 'happy-stacks-worktrees-monorepo-'));
+  t.after(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+  return dir;
+}
+
+async function writeHappyMonorepoStub({ rootDir, worktreeRoot }) {
+  const monoRoot = join(rootDir, 'components', 'happy');
+  await mkdir(join(monoRoot, 'expo-app'), { recursive: true });
+  await mkdir(join(monoRoot, 'cli'), { recursive: true });
+  await mkdir(join(monoRoot, 'server'), { recursive: true });
+  await writeFile(join(monoRoot, 'expo-app', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'cli', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'server', 'package.json'), '{}\n', 'utf-8');
+
+  // Also stub a monorepo worktree root (same structure) for spec parsing.
+  await mkdir(join(worktreeRoot, 'expo-app'), { recursive: true });
+  await mkdir(join(worktreeRoot, 'cli'), { recursive: true });
+  await mkdir(join(worktreeRoot, 'server'), { recursive: true });
+  await writeFile(join(worktreeRoot, '.git'), 'gitdir: /tmp/fake\n', 'utf-8');
+  return { monoRoot };
+}
+
+test('worktreeSpecFromDir normalizes monorepo package dirs to the worktree spec', async (t) => {
+  const rootDir = await withTempRoot(t);
+  const env = { HAPPY_STACKS_WORKSPACE_DIR: rootDir };
+
+  const wtRoot = join(rootDir, 'components', '.worktrees', 'happy', 'slopus', 'pr', '123-fix-monorepo');
+  await mkdir(wtRoot, { recursive: true });
+  await writeHappyMonorepoStub({ rootDir, worktreeRoot: wtRoot });
+
+  assert.equal(
+    worktreeSpecFromDir({ rootDir, component: 'happy', dir: join(wtRoot, 'expo-app'), env }),
+    'slopus/pr/123-fix-monorepo'
+  );
+  assert.equal(
+    worktreeSpecFromDir({ rootDir, component: 'happy-cli', dir: join(wtRoot, 'cli'), env }),
+    'slopus/pr/123-fix-monorepo'
+  );
+  assert.equal(
+    worktreeSpecFromDir({ rootDir, component: 'happy-server', dir: join(wtRoot, 'server'), env }),
+    'slopus/pr/123-fix-monorepo'
+  );
+});

package/scripts/utils/handy_master_secret.mjs

@@ -0,0 +1,94 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import { parseDotenv } from './env/dotenv.mjs';
+import { resolveStackEnvPath } from './paths/paths.mjs';
+import { getLegacyHappyBaseDir, isLegacyAuthSourceName } from './auth_sources.mjs';
+
+async function readTextIfExists(path) {
+  try {
+    if (!path || !existsSync(path)) return null;
+    const raw = await readFile(path, 'utf-8');
+    const t = raw.trim();
+    return t ? t : null;
+  } catch {
+    return null;
+  }
+}
+
+function parseEnvToObject(raw) {
+  const parsed = parseDotenv(raw ?? '');
+  return Object.fromEntries(parsed.entries());
+}
+
+function getEnvValue(env, key) {
+  const v = (env?.[key] ?? '').toString().trim();
+  return v || '';
+}
+
+function stackExistsSync(stackName) {
+  if (stackName === 'main') return true;
+  const envPath = resolveStackEnvPath(stackName).envPath;
+  return existsSync(envPath);
+}
+
+export async function resolveHandyMasterSecretFromStack({
+  stackName,
+  requireStackExists = false,
+  allowLegacyAuthSource = true,
+  allowLegacyMainFallback = true,
+} = {}) {
+  const name = String(stackName ?? '').trim() || 'main';
+
+  if (isLegacyAuthSourceName(name)) {
+    if (!allowLegacyAuthSource) {
+      throw new Error(
+        '[auth] legacy auth source is disabled in sandbox mode.\n' +
+          'Reason: it reads from ~/.happy (global user state).\n' +
+          'If you really want this, set: HAPPY_STACKS_SANDBOX_ALLOW_GLOBAL=1'
+      );
+    }
+    const baseDir = getLegacyHappyBaseDir();
+    const legacySecretPath = join(baseDir, 'server-light', 'handy-master-secret.txt');
+    const secret = await readTextIfExists(legacySecretPath);
+    return secret ? { secret, source: legacySecretPath } : { secret: null, source: null };
+  }
+
+  if (requireStackExists && !stackExistsSync(name)) {
+    throw new Error(`[auth] cannot copy auth: source stack "${name}" does not exist`);
+  }
+
+  const resolved = resolveStackEnvPath(name);
+  const sourceBaseDir = resolved.baseDir;
+  const sourceEnvPath = resolved.envPath;
+  const raw = await readTextIfExists(sourceEnvPath);
+  const env = raw ? parseEnvToObject(raw) : {};
+
+  const inline = getEnvValue(env, 'HANDY_MASTER_SECRET');
+  if (inline) {
+    return { secret: inline, source: `${sourceEnvPath} (HANDY_MASTER_SECRET)` };
+  }
+
+  const secretFile = getEnvValue(env, 'HAPPY_STACKS_HANDY_MASTER_SECRET_FILE');
+  if (secretFile) {
+    const secret = await readTextIfExists(secretFile);
+    if (secret) return { secret, source: secretFile };
+  }
+
+  const dataDir = getEnvValue(env, 'HAPPY_SERVER_LIGHT_DATA_DIR') || join(sourceBaseDir, 'server-light');
+  const secretPath = join(dataDir, 'handy-master-secret.txt');
+  const secret = await readTextIfExists(secretPath);
+  if (secret) return { secret, source: secretPath };
+
+  // Last-resort legacy: if main has never been migrated to stack dirs.
+  if (name === 'main' && allowLegacyMainFallback) {
+    const legacy = join(homedir(), '.happy', 'server-light', 'handy-master-secret.txt');
+    const legacySecret = await readTextIfExists(legacy);
+    if (legacySecret) return { secret: legacySecret, source: legacy };
+  }
+
+  return { secret: null, source: null };
+}
+

package/scripts/utils/mobile/config.mjs

@@ -0,0 +1,31 @@
+import { sanitizeBundleIdSegment, sanitizeUrlScheme } from './identifiers.mjs';
+
+export function resolveMobileExpoConfig({ env = process.env } = {}) {
+  const user = sanitizeBundleIdSegment(env.USER ?? env.USERNAME ?? 'user');
+  const defaultLocalBundleId = `com.happy.local.${user}.dev`;
+
+  const appEnv = env.APP_ENV ?? env.HAPPY_STACKS_APP_ENV ?? env.HAPPY_LOCAL_APP_ENV ?? 'development';
+  const iosAppName = (env.HAPPY_STACKS_IOS_APP_NAME ?? env.HAPPY_LOCAL_IOS_APP_NAME ?? '').toString();
+  const iosBundleId = (env.HAPPY_STACKS_IOS_BUNDLE_ID ?? env.HAPPY_LOCAL_IOS_BUNDLE_ID ?? defaultLocalBundleId).toString();
+  // Happy Stacks convention:
+  // - dev-client QR should open a dedicated "Happy Stacks Dev" app (not a per-stack release build)
+  // - so default to a stable happy-stacks-specific scheme unless explicitly overridden.
+  const scheme = sanitizeUrlScheme(
+    (env.HAPPY_STACKS_MOBILE_SCHEME ??
+      env.HAPPY_LOCAL_MOBILE_SCHEME ??
+      env.HAPPY_STACKS_DEV_CLIENT_SCHEME ??
+      env.HAPPY_LOCAL_DEV_CLIENT_SCHEME ??
+      'happystacks-dev')
+      .toString()
+  );
+  const host = (env.HAPPY_STACKS_MOBILE_HOST ?? env.HAPPY_LOCAL_MOBILE_HOST ?? 'lan').toString();
+
+  return {
+    appEnv,
+    iosAppName,
+    iosBundleId,
+    scheme,
+    host,
+  };
+}
+

package/scripts/utils/mobile/dev_client_links.mjs

@@ -0,0 +1,60 @@
+import { getEnvValueAny } from '../env/values.mjs';
+import { pickLanIpv4 } from '../net/lan_ip.mjs';
+import { resolveMobileExpoConfig } from './config.mjs';
+
+function normalizeHostMode(raw) {
+  const v = String(raw ?? '').trim().toLowerCase();
+  if (v === 'localhost' || v === 'local') return 'localhost';
+  if (v === 'lan' || v === 'ip') return 'lan';
+  if (v === 'tunnel') return 'tunnel';
+  return v || 'lan';
+}
+
+export function resolveMobileHostMode(env = process.env) {
+  // Prefer explicit host vars (so TUI/setup-pr match the same knobs Expo uses).
+  const raw =
+    getEnvValueAny(env, ['HAPPY_STACKS_MOBILE_HOST', 'HAPPY_LOCAL_MOBILE_HOST']) ||
+    resolveMobileExpoConfig({ env }).host ||
+    'lan';
+  return normalizeHostMode(raw);
+}
+
+export function resolveMobileScheme(env = process.env) {
+  return String(resolveMobileExpoConfig({ env }).scheme || '').trim();
+}
+
+export function resolveMetroUrlForMobile({ env = process.env, port }) {
+  const p = Number(port);
+  if (!Number.isFinite(p) || p <= 0) return '';
+
+  const mode = resolveMobileHostMode(env);
+  if (mode === 'localhost') {
+    return `http://localhost:${p}`;
+  }
+  if (mode === 'lan') {
+    const ip = pickLanIpv4();
+    return `http://${ip || 'localhost'}:${p}`;
+  }
+  // Tunnel URLs are controlled by Expo; we can't reliably derive them locally.
+  // Fall back to localhost so the URL is at least correct for the host machine.
+  return `http://localhost:${p}`;
+}
+
+export function resolveDevClientDeepLink({ scheme, metroUrl }) {
+  const s = String(scheme ?? '').trim();
+  const url = String(metroUrl ?? '').trim();
+  if (!url) return '';
+  if (!s) return url;
+  return `${s}://expo-development-client/?url=${encodeURIComponent(url)}`;
+}
+
+export function resolveMobileQrPayload({ env = process.env, port }) {
+  const metroUrl = resolveMetroUrlForMobile({ env, port });
+  const scheme = resolveMobileScheme(env);
+  const deepLink = resolveDevClientDeepLink({ scheme, metroUrl });
+  // Match Expo CLI / @expo/cli UrlCreator: QR encodes the dev-client deep link.
+  // Note: iOS Camera will still offer to open custom schemes when the app is installed.
+  const payload = deepLink || metroUrl;
+  return { scheme, metroUrl, deepLink, payload };
+}
+

package/scripts/utils/mobile/identifiers.mjs

@@ -0,0 +1,47 @@
+function sanitizeToken(raw, { allowDots = false } = {}) {
+  const s = (raw ?? '').toString().trim().toLowerCase();
+  const re = allowDots ? /[^a-z0-9.-]+/g : /[^a-z0-9-]+/g;
+  const out = s.replace(re, '-').replace(/^-+|-+$/g, '').replace(/-+/g, '-');
+  return out;
+}
+
+export function sanitizeBundleIdSegment(s) {
+  const seg = sanitizeToken(s, { allowDots: false });
+  if (!seg) return 'app';
+  // Bundle id segments should not start with a digit; prefix if needed.
+  return /^[a-z]/.test(seg) ? seg : `s${seg}`;
+}
+
+export function sanitizeUrlScheme(s) {
+  // iOS URL schemes must start with a letter and may contain letters/digits/+.-.
+  const raw = (s ?? '').toString().trim().toLowerCase();
+  const cleaned = raw.replace(/[^a-z0-9+.-]+/g, '-').replace(/-+/g, '-').replace(/^-+|-+$/g, '');
+  if (!cleaned) return 'happystacks-dev';
+  return /^[a-z]/.test(cleaned) ? cleaned : `h${cleaned}`;
+}
+
+export function stackSlugForMobileIds(stackName) {
+  const raw = (stackName ?? '').toString().trim();
+  return sanitizeBundleIdSegment(raw || 'stack');
+}
+
+export function defaultDevClientIdentity({ user = null } = {}) {
+  const u = sanitizeBundleIdSegment(user ?? 'user');
+  return {
+    iosAppName: 'Happy Stacks Dev',
+    iosBundleId: `com.happystacks.dev.${u}`,
+    scheme: 'happystacks-dev',
+  };
+}
+
+export function defaultStackReleaseIdentity({ stackName, user = null, appName = null } = {}) {
+  const slug = stackSlugForMobileIds(stackName);
+  const u = sanitizeBundleIdSegment(user ?? 'user');
+  const label = (appName ?? '').toString().trim();
+  return {
+    iosAppName: label || `Happy (${stackName})`,
+    iosBundleId: `com.happystacks.stack.${u}.${slug}`,
+    scheme: sanitizeUrlScheme(`happystacks-${slug}`),
+  };
+}
+

package/scripts/utils/mobile/identifiers.test.mjs

@@ -0,0 +1,42 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  defaultDevClientIdentity,
+  defaultStackReleaseIdentity,
+  sanitizeBundleIdSegment,
+  sanitizeUrlScheme,
+  stackSlugForMobileIds,
+} from './identifiers.mjs';
+
+test('sanitizeBundleIdSegment produces a safe segment', () => {
+  assert.equal(sanitizeBundleIdSegment('  PR272-107  '), 'pr272-107');
+  assert.equal(sanitizeBundleIdSegment('---'), 'app');
+  assert.equal(sanitizeBundleIdSegment('123'), 's123');
+});
+
+test('sanitizeUrlScheme produces a safe scheme', () => {
+  assert.equal(sanitizeUrlScheme('HappyStacks-Dev'), 'happystacks-dev');
+  assert.equal(sanitizeUrlScheme('123bad'), 'h123bad');
+  assert.equal(sanitizeUrlScheme(''), 'happystacks-dev');
+});
+
+test('stackSlugForMobileIds derives a stable slug', () => {
+  assert.equal(stackSlugForMobileIds('pr272-107-fixes-2026-01-15'), 'pr272-107-fixes-2026-01-15');
+  assert.equal(stackSlugForMobileIds('  Weird Name  '), 'weird-name');
+});
+
+test('defaultDevClientIdentity is stable and safe', () => {
+  const id = defaultDevClientIdentity({ user: 'Leeroy' });
+  assert.equal(id.iosAppName, 'Happy Stacks Dev');
+  assert.equal(id.scheme, 'happystacks-dev');
+  assert.equal(id.iosBundleId, 'com.happystacks.dev.leeroy');
+});
+
+test('defaultStackReleaseIdentity is per-stack', () => {
+  const id = defaultStackReleaseIdentity({ stackName: 'pr272-107', user: 'Leeroy' });
+  assert.equal(id.iosBundleId, 'com.happystacks.stack.leeroy.pr272-107');
+  assert.equal(id.scheme, 'happystacks-pr272-107');
+  assert.equal(id.iosAppName, 'Happy (pr272-107)');
+});
+