@happier-dev/stack 0.1.0 → 0.2.0

package/scripts/utils/expo/expo_shared_tmpdir.test.mjs

@@ -0,0 +1,38 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+
+import { resolveExpoTmpDir } from './expo.mjs';
+
+function sha1_12(s) {
+  return createHash('sha1').update(String(s ?? '')).digest('hex').slice(0, 12);
+}
+
+test('resolveExpoTmpDir returns default when shared tmpdir is not configured', () => {
+  const def = '/tmp/default';
+  const got = resolveExpoTmpDir({
+    env: {},
+    defaultTmpDir: def,
+    kind: 'expo-dev',
+    projectDir: '/proj/apps/ui',
+  });
+  assert.equal(got, def);
+});
+
+test('resolveExpoTmpDir uses shared base dir + key when configured', () => {
+  const base = '/cache/expo';
+  const key = 'happier-dev/happier';
+  const kind = 'expo-dev';
+  const expected = join(base, 'tmp', kind, sha1_12(key));
+  const got = resolveExpoTmpDir({
+    env: {
+      HAPPIER_STACK_EXPO_SHARED_TMPDIR_BASE_DIR: base,
+      HAPPIER_STACK_EXPO_SHARED_TMPDIR_KEY: key,
+    },
+    defaultTmpDir: '/tmp/default',
+    kind,
+    projectDir: '/proj/apps/ui',
+  });
+  assert.equal(got, expected);
+});

package/scripts/utils/expo/expo_state_running.test.mjs

@@ -1,6 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import http from 'node:http';
+import { spawn } from 'node:child_process';
 import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
@@ -46,3 +47,68 @@ test('isStateProcessRunning does not treat occupied port as running when /status
   }
 });
 
+async function spawnMetroLikeServer({ includeNeedle = '' } = {}) {
+  const needle = String(includeNeedle ?? '').trim();
+  const script = `
+    const http = require('http');
+    const needle = process.argv[2] || '';
+    const srv = http.createServer((req, res) => {
+      if (req.url === '/status') {
+        res.writeHead(200, { 'content-type': 'text/plain' });
+        res.end('packager-status:running');
+        return;
+      }
+      res.writeHead(200, { 'content-type': 'text/plain' });
+      res.end('ok');
+    });
+    srv.listen(0, '127.0.0.1', () => {
+      const port = srv.address().port;
+      console.log(JSON.stringify({ port, pid: process.pid, needle }));
+    });
+    setInterval(() => {}, 1000);
+  `.trim();
+  const args = ['-e', script, ...(needle ? [needle] : [])];
+  const child = spawn(process.execPath, args, { stdio: ['ignore', 'pipe', 'ignore'] });
+  const line = await new Promise((resolve, reject) => {
+    let buf = '';
+    child.stdout.on('data', (d) => {
+      buf += d.toString();
+      const idx = buf.indexOf('\n');
+      if (idx >= 0) resolve(buf.slice(0, idx));
+    });
+    child.on('error', reject);
+    child.on('exit', (code) => reject(new Error(`[test] metro-like child exited unexpectedly (code=${code ?? 'unknown'})`)));
+  });
+  const meta = JSON.parse(String(line ?? '').trim());
+  return {
+    child,
+    port: Number(meta.port),
+    async kill() {
+      try {
+        child.kill('SIGKILL');
+      } catch {
+        // ignore
+      }
+    },
+  };
+}
+
+test('isStateProcessRunning does not treat an unrelated Metro on the same port as running when projectDir mismatches', async () => {
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-expo-state-running-'));
+  const metro = await spawnMetroLikeServer();
+  try {
+    assert.ok(Number.isFinite(metro.port) && metro.port > 0, 'expected metro-like child to report a port');
+    const statePath = join(tmp, 'expo.state.json');
+    await writeFile(
+      statePath,
+      JSON.stringify({ pid: 999999, port: metro.port, projectDir: '/tmp/definitely-not-the-metro-project' }, null, 2) + '\n',
+      'utf-8'
+    );
+
+    const res = await isStateProcessRunning(statePath);
+    assert.equal(res.running, false);
+  } finally {
+    await metro.kill().catch(() => {});
+    await rm(tmp, { recursive: true, force: true });
+  }
+});

package/scripts/utils/expo/expo_wait_for_metro.test.mjs

@@ -0,0 +1,50 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { waitForExpoMetroRunning } from './expo.mjs';
+
+test('waitForExpoMetroRunning waits until Metro reports running', async () => {
+  let probes = 0;
+  const result = await waitForExpoMetroRunning({
+    port: 8081,
+  }, {
+    looksLikeExpoMetroImpl: async () => {
+      probes += 1;
+      return probes >= 3;
+    },
+    delayImpl: async () => {},
+    nowMsImpl: (() => {
+      let now = 0;
+      return () => {
+        now += 10;
+        return now;
+      };
+    })(),
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.probes, 3);
+});
+
+test('waitForExpoMetroRunning returns a non-ok result when the timeout elapses', async () => {
+  const result = await waitForExpoMetroRunning({
+    port: 8081,
+    timeoutMs: 25,
+    intervalMs: 10,
+  }, {
+    looksLikeExpoMetroImpl: async () => false,
+    delayImpl: async () => {},
+    nowMsImpl: (() => {
+      let now = 0;
+      return () => {
+        now += 10;
+        return now;
+      };
+    })(),
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.reason, 'timeout');
+  assert.equal(result.probes >= 2, true);
+});
+

package/scripts/utils/expo/metro_ports.mjs

@@ -1,4 +1,4 @@
-import { isTcpPortFree, pickNextFreeTcpPort } from '../net/ports.mjs';
+import { isTcpPortListening, listListenPids, pickNextFreeTcpPort } from '../net/ports.mjs';
 
 function hashStringToInt(s) {
   let h = 0;
@@ -37,8 +37,15 @@ export async function pickMetroPort({
 } = {}) {
   const forced = coercePositiveInt(forcedPort);
   if (forced && !reservedPorts.has(forced)) {
-    const ok = await isTcpPortFree(forced, { host });
-    if (ok) return forced;
+    // Avoid bind-based probing for the forced port path: concurrent probes can temporarily occupy the port
+    // and cause false negatives (flaky forced-port selection).
+    //
+    // Strategy:
+    // - First detect any real listener via lsof (non-invasive; catches IPv6 listeners on macOS).
+    // - Then do a best-effort connect probe (works even when lsof is missing).
+    const pids = await listListenPids(forced);
+    const listening = pids.length ? true : await isTcpPortListening(forced, { host });
+    if (!listening) return forced;
   }
   return await pickNextFreeTcpPort(startPort, { reservedPorts, host });
 }

package/scripts/utils/git/default_branch.mjs

@@ -0,0 +1,22 @@
+import { runCapture } from '../proc/proc.mjs';
+
+function trim(s) {
+  return String(s ?? '').trim();
+}
+
+export async function resolveDefaultRemoteBranch({ dir, remote = 'origin' } = {}) {
+  const repoDir = trim(dir);
+  const r = trim(remote) || 'origin';
+  if (!repoDir) return '';
+
+  let ref = '';
+  try {
+    ref = trim(await runCapture('git', ['symbolic-ref', '-q', `refs/remotes/${r}/HEAD`], { cwd: repoDir }));
+  } catch {
+    return '';
+  }
+  if (!ref) return '';
+  const prefix = `refs/remotes/${r}/`;
+  if (!ref.startsWith(prefix)) return '';
+  return ref.slice(prefix.length);
+}

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

@@ -0,0 +1,45 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { runCapture } from '../proc/proc.mjs';
+
+import { resolveDefaultRemoteBranch } from './default_branch.mjs';
+
+async function initRepo(dir) {
+  await runCapture('git', ['init'], { cwd: dir });
+  await runCapture('git', ['config', 'user.email', 'test@example.com'], { cwd: dir });
+  await runCapture('git', ['config', 'user.name', 'Test'], { cwd: dir });
+  await writeFile(join(dir, 'README.md'), 'hello\n', 'utf-8');
+  await runCapture('git', ['add', '.'], { cwd: dir });
+  await runCapture('git', ['commit', '-m', 'seed'], { cwd: dir });
+}
+
+test('resolveDefaultRemoteBranch reads origin/HEAD symbolic ref', async (t) => {
+  const dir = await mkdtemp(join(tmpdir(), 'hstack-default-branch-'));
+  t.after(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  await initRepo(dir);
+  const head = (await runCapture('git', ['rev-parse', 'HEAD'], { cwd: dir })).trim();
+
+  await runCapture('git', ['update-ref', 'refs/remotes/origin/dev', head], { cwd: dir });
+  await runCapture('git', ['symbolic-ref', 'refs/remotes/origin/HEAD', 'refs/remotes/origin/dev'], { cwd: dir });
+
+  const branch = await resolveDefaultRemoteBranch({ dir, remote: 'origin' });
+  assert.equal(branch, 'dev');
+});
+
+test('resolveDefaultRemoteBranch returns empty when remote head is missing', async (t) => {
+  const dir = await mkdtemp(join(tmpdir(), 'hstack-default-branch-missing-'));
+  t.after(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  await initRepo(dir);
+
+  const branch = await resolveDefaultRemoteBranch({ dir, remote: 'origin' });
+  assert.equal(branch, '');
+});

package/scripts/utils/git/dev_checkout.mjs

@@ -59,7 +59,7 @@ export async function ensureDevCheckout({ rootDir, env = process.env, remote = '
   const devBranch = resolveDevBranchName(env);
 
   if (!existsSync(mainDir) || !existsSync(join(mainDir, '.git'))) {
-    throw new Error(`[dev] missing main checkout at ${mainDir}\nFix: run \`hstack bootstrap --clone\` (or \`hstack setup\`).`);
+    throw new Error(`[dev] missing main checkout at ${mainDir}\nFix: run \`hstack bootstrap --clone\` (or \`hstack setup-from-source\`).`);
   }
 
   const syncRemote = await resolveDevSyncRemote({ repoDir: mainDir, env, preferred: remote });

package/scripts/utils/git/fast_forward_to_remote.mjs

@@ -0,0 +1,136 @@
+import { runCapture } from '../proc/proc.mjs';
+
+function trim(s) {
+  return String(s ?? '').trim();
+}
+
+function parseCounts(out) {
+  const s = trim(out);
+  if (!s) return { behind: null, ahead: null };
+  const [left, right] = s.split(/\s+/g).map((n) => Number(n));
+  return {
+    behind: Number.isFinite(left) ? left : null,
+    ahead: Number.isFinite(right) ? right : null,
+  };
+}
+
+/**
+ * Best-effort fast-forward a local branch to a remote ref:
+ * - checks working tree is clean
+ * - fetches remote branch
+ * - fast-forwards via `git merge --ff-only`
+ *
+ * Never force-resets or rewrites history.
+ */
+export async function fastForwardBranchToRemote({ dir, remote = 'origin', branch }) {
+  const repoDir = trim(dir);
+  const r = trim(remote) || 'origin';
+  const b = trim(branch);
+  if (!repoDir) {
+    return { ok: false, updated: false, reason: 'missing-dir', error: '[git] missing dir' };
+  }
+  if (!b) {
+    return { ok: false, updated: false, reason: 'missing-branch', error: '[git] missing branch' };
+  }
+
+  // Ensure we're on the requested branch (best-effort).
+  let headRef = '';
+  try {
+    headRef = trim(await runCapture('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: repoDir }));
+  } catch (e) {
+    return {
+      ok: false,
+      updated: false,
+      reason: 'not-a-git-repo',
+      error: e instanceof Error ? e.message : String(e),
+    };
+  }
+  if (headRef && headRef !== b) {
+    try {
+      await runCapture('git', ['checkout', '-q', b], { cwd: repoDir });
+    } catch (e) {
+      return {
+        ok: false,
+        updated: false,
+        reason: 'checkout-failed',
+        error: e instanceof Error ? e.message : String(e),
+      };
+    }
+  }
+
+  // Refuse to fast-forward a dirty working tree.
+  const dirty = trim(await runCapture('git', ['status', '--porcelain'], { cwd: repoDir }).catch(() => ''));
+  if (dirty) {
+    return { ok: false, updated: false, reason: 'dirty', error: '[git] working tree is not clean' };
+  }
+
+  const remoteRef = `${r}/${b}`;
+  let oldHead = '';
+  try {
+    oldHead = trim(await runCapture('git', ['rev-parse', 'HEAD'], { cwd: repoDir }));
+  } catch {
+    oldHead = '';
+  }
+
+  try {
+    await runCapture('git', ['fetch', '--quiet', r, b], { cwd: repoDir });
+  } catch (e) {
+    return {
+      ok: false,
+      updated: false,
+      reason: 'fetch-failed',
+      error: e instanceof Error ? e.message : String(e),
+    };
+  }
+
+  let remoteHead = '';
+  try {
+    remoteHead = trim(await runCapture('git', ['rev-parse', remoteRef], { cwd: repoDir }));
+  } catch (e) {
+    return {
+      ok: false,
+      updated: false,
+      reason: 'remote-ref-missing',
+      error: e instanceof Error ? e.message : String(e),
+    };
+  }
+
+  if (oldHead && remoteHead && oldHead === remoteHead) {
+    return { ok: true, updated: false, reason: 'up-to-date', oldHead, newHead: oldHead };
+  }
+
+  const counts = parseCounts(
+    await runCapture('git', ['rev-list', '--left-right', '--count', `${remoteRef}...HEAD`], { cwd: repoDir }).catch(() => '')
+  );
+  const behind = counts.behind ?? 0;
+  const ahead = counts.ahead ?? 0;
+
+  if (behind === 0 && ahead > 0) {
+    return { ok: false, updated: false, reason: 'ahead', oldHead, remoteHead, behind, ahead };
+  }
+  if (behind > 0 && ahead > 0) {
+    return { ok: false, updated: false, reason: 'diverged', oldHead, remoteHead, behind, ahead };
+  }
+  if (behind === 0 && ahead === 0) {
+    // Some repos can hit this state when HEAD is detached but points at the same commit.
+    return { ok: true, updated: false, reason: 'up-to-date', oldHead, newHead: oldHead };
+  }
+
+  try {
+    await runCapture('git', ['merge', '--ff-only', remoteRef], { cwd: repoDir });
+  } catch (e) {
+    return {
+      ok: false,
+      updated: false,
+      reason: 'ff-failed',
+      error: e instanceof Error ? e.message : String(e),
+      oldHead,
+      remoteHead,
+      behind,
+      ahead,
+    };
+  }
+
+  const newHead = trim(await runCapture('git', ['rev-parse', 'HEAD'], { cwd: repoDir }).catch(() => remoteHead));
+  return { ok: true, updated: true, reason: 'fast-forwarded', oldHead, newHead, remoteHead, behind, ahead };
+}

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

@@ -0,0 +1,90 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { spawnSync } from 'node:child_process';
+
+import { fastForwardBranchToRemote } from './fast_forward_to_remote.mjs';
+
+function git(cwd, args, { allowFail = false } = {}) {
+  const res = spawnSync('git', args, { cwd, encoding: 'utf-8' });
+  if (!allowFail && res.status !== 0) {
+    throw new Error(`git ${args.join(' ')} failed (cwd=${cwd})\n${res.stderr || res.stdout || ''}`.trim());
+  }
+  return String(res.stdout ?? '').trim();
+}
+
+function commitAll(cwd, message) {
+  git(cwd, ['add', '-A']);
+  git(cwd, ['-c', 'user.email=test@example.com', '-c', 'user.name=test', 'commit', '-m', message]);
+}
+
+async function setupRemoteAndClone(t) {
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-ff-remote-'));
+  t.after(async () => {
+    await rm(tmp, { recursive: true, force: true });
+  });
+
+  const remoteBare = join(tmp, 'remote.git');
+  git(tmp, ['init', '--bare', remoteBare]);
+
+  const work = join(tmp, 'work');
+  git(tmp, ['clone', remoteBare, work]);
+  await writeFile(join(work, 'README.md'), 'one\n', 'utf-8');
+  commitAll(work, 'init');
+  git(work, ['branch', '-M', 'main']);
+  git(work, ['push', 'origin', 'main']);
+
+  const local = join(tmp, 'local');
+  git(tmp, ['clone', remoteBare, local]);
+  git(local, ['checkout', '-q', 'main']);
+
+  return { tmp, remoteBare, work, local };
+}
+
+test('fastForwardBranchToRemote fast-forwards a clean repo that is behind', async (t) => {
+  const { work, local } = await setupRemoteAndClone(t);
+
+  const beforeLocal = git(local, ['rev-parse', 'HEAD']);
+
+  await writeFile(join(work, 'README.md'), 'two\n', 'utf-8');
+  commitAll(work, 'bump');
+  git(work, ['push', 'origin', 'main']);
+  const remoteHead = git(work, ['rev-parse', 'HEAD']);
+
+  const res = await fastForwardBranchToRemote({ dir: local, remote: 'origin', branch: 'main' });
+  assert.equal(res.ok, true);
+  assert.equal(res.updated, true);
+
+  const afterLocal = git(local, ['rev-parse', 'HEAD']);
+  assert.notEqual(afterLocal, beforeLocal);
+  assert.equal(afterLocal, remoteHead);
+});
+
+test('fastForwardBranchToRemote refuses to update a dirty working tree', async (t) => {
+  const { work, local } = await setupRemoteAndClone(t);
+
+  await writeFile(join(local, 'DIRTY.txt'), 'x\n', 'utf-8');
+
+  await writeFile(join(work, 'README.md'), 'two\n', 'utf-8');
+  commitAll(work, 'bump');
+  git(work, ['push', 'origin', 'main']);
+
+  const beforeLocal = git(local, ['rev-parse', 'HEAD']);
+  const res = await fastForwardBranchToRemote({ dir: local, remote: 'origin', branch: 'main' });
+  assert.equal(res.ok, false);
+  assert.equal(res.reason, 'dirty');
+  assert.equal(git(local, ['rev-parse', 'HEAD']), beforeLocal);
+});
+
+test('fastForwardBranchToRemote refuses to update when local is ahead of remote', async (t) => {
+  const { local } = await setupRemoteAndClone(t);
+
+  await writeFile(join(local, 'AHEAD.txt'), 'x\n', 'utf-8');
+  commitAll(local, 'ahead');
+
+  const res = await fastForwardBranchToRemote({ dir: local, remote: 'origin', branch: 'main' });
+  assert.equal(res.ok, false);
+  assert.equal(res.reason, 'ahead');
+});

package/scripts/utils/git/refs.mjs

@@ -4,6 +4,24 @@ export function parseGithubPullRequest(input) {
   if (/^\d+$/.test(raw)) {
     return { number: Number(raw), owner: null, repo: null };
   }
+  // owner/repo#<num> (common shorthand in CLI/issue trackers)
+  const shorthand = raw.match(/^(?<owner>[A-Za-z0-9_.-]+)\/(?<repo>[A-Za-z0-9_.-]+)#(?<num>\d+)$/);
+  if (shorthand?.groups?.num) {
+    return {
+      number: Number(shorthand.groups.num),
+      owner: shorthand.groups.owner ?? null,
+      repo: shorthand.groups.repo ?? null,
+    };
+  }
+  // owner/repo/pull/<num> (GitHub path form without scheme/host)
+  const pathForm = raw.match(/^(?<owner>[A-Za-z0-9_.-]+)\/(?<repo>[A-Za-z0-9_.-]+)\/pull\/(?<num>\d+)$/);
+  if (pathForm?.groups?.num) {
+    return {
+      number: Number(pathForm.groups.num),
+      owner: pathForm.groups.owner ?? null,
+      repo: pathForm.groups.repo ?? null,
+    };
+  }
   // https://github.com/<owner>/<repo>/pull/<num>
   const m = raw.match(/github\.com\/(?<owner>[^/]+)\/(?<repo>[^/]+)\/pull\/(?<num>\d+)/);
   if (!m?.groups?.num) return null;
@@ -23,4 +41,3 @@ export function sanitizeSlugPart(s) {
     .replace(/-+/g, '-')
     .replace(/^-+|-+$/g, '');
 }
-

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

@@ -0,0 +1,37 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { parseGithubPullRequest } from './refs.mjs';
+
+test('parseGithubPullRequest parses a PR number', () => {
+  assert.deepEqual(parseGithubPullRequest('58'), { number: 58, owner: null, repo: null });
+});
+
+test('parseGithubPullRequest parses a GitHub PR URL', () => {
+  assert.deepEqual(parseGithubPullRequest('https://github.com/happier-dev/happier/pull/58'), {
+    number: 58,
+    owner: 'happier-dev',
+    repo: 'happier',
+  });
+});
+
+test('parseGithubPullRequest parses an owner/repo#number PR ref', () => {
+  assert.deepEqual(parseGithubPullRequest('happier-dev/happier#58'), {
+    number: 58,
+    owner: 'happier-dev',
+    repo: 'happier',
+  });
+});
+
+test('parseGithubPullRequest parses an owner/repo/pull/number PR ref', () => {
+  assert.deepEqual(parseGithubPullRequest('happier-dev/happier/pull/77'), {
+    number: 77,
+    owner: 'happier-dev',
+    repo: 'happier',
+  });
+});
+
+test('parseGithubPullRequest returns null for invalid input', () => {
+  assert.equal(parseGithubPullRequest('happier-dev/happier'), null);
+  assert.equal(parseGithubPullRequest('happier-dev/happier#'), null);
+});

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

@@ -1,30 +1,21 @@
 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 { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 
+import { createTempFixture } from '../../testkit/core/temp_fixture.mjs';
+import { ensureMinimalMonorepoLayout } from '../../testkit/core/minimal_monorepo_layout.mjs';
 import { worktreeSpecFromDir } from './worktrees.mjs';
 
-async function withTempRoot(t) {
-  const dir = await mkdtemp(join(tmpdir(), 'happier-stack-worktrees-monorepo-'));
-  t.after(async () => {
-    await rm(dir, { recursive: true, force: true });
-  });
-  return dir;
-}
-
 async function writeHappyMonorepoStub({ rootDir, worktreeRoot }) {
   void rootDir;
   // Stub a monorepo worktree root (apps/* markers + .git) for spec parsing.
-  await mkdir(join(worktreeRoot, 'apps', 'ui'), { recursive: true });
-  await mkdir(join(worktreeRoot, 'apps', 'cli'), { recursive: true });
-  await mkdir(join(worktreeRoot, 'apps', 'server'), { recursive: true });
-  await writeFile(join(worktreeRoot, '.git'), 'gitdir: /tmp/fake\n', 'utf-8');
+  await ensureMinimalMonorepoLayout(worktreeRoot, { writeGitDirMarker: true });
 }
 
 test('worktreeSpecFromDir normalizes monorepo package dirs to the worktree spec', async (t) => {
-  const rootDir = await withTempRoot(t);
+  const fixture = await createTempFixture(t, { prefix: 'happier-stack-worktrees-monorepo-' });
+  const rootDir = fixture.root;
   const env = { HAPPIER_STACK_WORKSPACE_DIR: rootDir };
 
   const wtRoot = join(rootDir, 'pr', '123-fix-monorepo');
@@ -46,7 +37,8 @@ test('worktreeSpecFromDir normalizes monorepo package dirs to the worktree spec'
 });
 
 test('worktreeSpecFromDir resolves the same spec from the monorepo root and nested unknown dirs', async (t) => {
-  const rootDir = await withTempRoot(t);
+  const fixture = await createTempFixture(t, { prefix: 'happier-stack-worktrees-monorepo-' });
+  const rootDir = fixture.root;
   const env = { HAPPIER_STACK_WORKSPACE_DIR: rootDir };
   const wtRoot = join(rootDir, 'pr', '456-pathstyle');
   await mkdir(join(wtRoot, 'docs', 'guides'), { recursive: true });

package/scripts/utils/menubar/swiftbar.mjs

@@ -75,7 +75,7 @@ export async function detectSwiftbarPluginInstalled({ pluginsDir, patterns = nul
   const dir = pluginsDir ?? (await resolveSwiftbarPluginsDir({ env }));
   if (!dir) return { pluginsDir: null, installed: false };
 
-  const pats = Array.isArray(patterns) && patterns.length ? patterns : ['hstack.*.sh'];
+  const pats = Array.isArray(patterns) && patterns.length ? patterns : ['hstack.*.sh', 'hstack-*.sh'];
   const regs = pats.map(globToRegExp).filter(Boolean);
   if (regs.length === 0) return { pluginsDir: dir, installed: false };
 
@@ -97,7 +97,7 @@ export async function removeSwiftbarPlugins({ pluginsDir, patterns = null, env =
   const dir = pluginsDir ?? (await resolveSwiftbarPluginsDir({ env }));
   if (!dir) return { ok: true, removed: false, pluginsDir: null };
 
-  const pats = Array.isArray(patterns) && patterns.length ? patterns : ['hstack.*.sh'];
+  const pats = Array.isArray(patterns) && patterns.length ? patterns : ['hstack.*.sh', 'hstack-*.sh'];
   const regs = pats.map(globToRegExp).filter(Boolean);
   if (regs.length === 0) return { ok: true, removed: false, pluginsDir: dir };
 

package/scripts/utils/mobile/config.mjs

@@ -20,7 +20,7 @@ export function resolveMobileExpoConfig({ env = process.env } = {}) {
     (env.HAPPIER_STACK_MOBILE_SCHEME ??
       env.HAPPIER_STACK_DEV_CLIENT_SCHEME ??
       env.EXPO_APP_SCHEME ??
-      'hstack-dev')
+      'happier-dev')
       .toString()
   );
   const host = (env.HAPPIER_STACK_MOBILE_HOST ?? 'lan').toString();

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

@@ -0,0 +1,9 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { resolveMobileExpoConfig } from './config.mjs';
+
+test('resolveMobileExpoConfig defaults dev-client scheme to happier-dev', () => {
+  const cfg = resolveMobileExpoConfig({ env: {} });
+  assert.equal(cfg.scheme, 'happier-dev');
+});