happy-stacks 0.3.0 → 0.5.0

package/scripts/utils/mobile/ios_xcodeproj_patch.mjs

@@ -0,0 +1,128 @@
+import { readdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { pathExists } from '../fs/fs.mjs';
+
+function sanitizeXcodeProductName(name) {
+  const raw = (name ?? '').toString().trim();
+  const out = raw
+    .replace(/[^A-Za-z0-9_-]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^[-_]+|[-_]+$/g, '');
+  return out || 'Happy';
+}
+
+async function listIosAppXcodeprojNames({ iosDir }) {
+  let entries = [];
+  try {
+    entries = await readdir(iosDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const names = entries
+    .filter((e) => e.isDirectory() && e.name.endsWith('.xcodeproj') && e.name.startsWith('Happy'))
+    .map((e) => e.name);
+
+  // Prefer the common names first to keep behavior stable if multiple projects exist.
+  const score = (name) => {
+    if (name === 'Happydev.xcodeproj') return 0;
+    if (name === 'Happy.xcodeproj') return 1;
+    return 2;
+  };
+  names.sort((a, b) => score(a) - score(b) || a.localeCompare(b));
+  return names;
+}
+
+export async function resolveIosAppXcodeProjects({ uiDir }) {
+  const iosDir = join(uiDir, 'ios');
+  const projectNames = await listIosAppXcodeprojNames({ iosDir });
+
+  const projects = [];
+  for (const projectName of projectNames) {
+    const pbxprojPath = join(iosDir, projectName, 'project.pbxproj');
+    if (!(await pathExists(pbxprojPath))) {
+      continue;
+    }
+
+    const appDirName = projectName.replace(/\.xcodeproj$/, '');
+    const infoPlistPath = join(iosDir, appDirName, 'Info.plist');
+
+    projects.push({
+      name: appDirName,
+      pbxprojPath,
+      infoPlistPath: (await pathExists(infoPlistPath)) ? infoPlistPath : null,
+    });
+  }
+
+  return projects;
+}
+
+export async function patchIosXcodeProjectsForSigningAndIdentity({
+  uiDir,
+  iosBundleId,
+  iosAppName = '',
+} = {}) {
+  const bundleId = (iosBundleId ?? '').toString().trim();
+  const appName = (iosAppName ?? '').toString().trim();
+  const productName = sanitizeXcodeProductName(appName);
+
+  if (!uiDir || !bundleId) {
+    return;
+  }
+
+  const projects = await resolveIosAppXcodeProjects({ uiDir });
+  if (projects.length === 0) {
+    return;
+  }
+
+  for (const project of projects) {
+    // Patch pbxproj: clear pinned signing fields so Expo can reconfigure and include provisioning update flags,
+    // and force a per-stack bundle id + optional PRODUCT_NAME.
+    try {
+      const raw = await readFile(project.pbxprojPath, 'utf-8');
+      let next = raw;
+
+      // Clear team identifiers (both TargetAttributes and build settings variants).
+      next = next.replaceAll(/^\s*DevelopmentTeam\s*=\s*[^;]+;\s*$/gm, '');
+      next = next.replaceAll(/^\s*DEVELOPMENT_TEAM\s*=\s*[^;]+;\s*$/gm, '');
+      // Clear any pinned provisioning profiles/specifiers (manual signing).
+      next = next.replaceAll(/^\s*PROVISIONING_PROFILE\s*=\s*[^;]+;\s*$/gm, '');
+      next = next.replaceAll(/^\s*PROVISIONING_PROFILE_SPECIFIER\s*=\s*[^;]+;\s*$/gm, '');
+      // Some projects pin code signing identity; remove to let Xcode resolve based on the selected team.
+      next = next.replaceAll(/^\s*CODE_SIGN_IDENTITY\s*=\s*[^;]+;\s*$/gm, '');
+      next = next.replaceAll(/^\s*"CODE_SIGN_IDENTITY\\[sdk=iphoneos\\*\\]"\s*=\s*[^;]+;\s*$/gm, '');
+
+      next = next.replaceAll(/PRODUCT_BUNDLE_IDENTIFIER = [^;]+;/g, `PRODUCT_BUNDLE_IDENTIFIER = ${bundleId};`);
+
+      if (appName) {
+        // Expo CLI appears to treat some escaped build paths as literal (e.g. "Happy\\ (stack).app"),
+        // so keep PRODUCT_NAME free of spaces to avoid breaking post-build Info.plist parsing.
+        next = next.replaceAll(/PRODUCT_NAME = [^;]+;/g, `PRODUCT_NAME = ${productName};`);
+      }
+
+      if (next !== raw) {
+        await writeFile(project.pbxprojPath, next, 'utf-8');
+      }
+    } catch {
+      // ignore project patch errors; Expo will surface actionable failures if needed
+    }
+
+    // Patch Info.plist display name when possible (home screen label).
+    if (appName && project.infoPlistPath) {
+      try {
+        const plistRaw = await readFile(project.infoPlistPath, 'utf-8');
+        const escaped = appName.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+        const replaced = plistRaw.replace(
+          /(<key>CFBundleDisplayName<\/key>\s*<string>)([\s\S]*?)(<\/string>)/m,
+          `$1${escaped}$3`
+        );
+        if (replaced !== plistRaw) {
+          await writeFile(project.infoPlistPath, replaced, 'utf-8');
+        }
+      } catch {
+        // ignore
+      }
+    }
+  }
+}

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

@@ -0,0 +1,98 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { patchIosXcodeProjectsForSigningAndIdentity } from './ios_xcodeproj_patch.mjs';
+
+async function makeTempUiDir() {
+  return await mkdtemp(join(tmpdir(), 'happy-stacks-mobile-'));
+}
+
+test('patchIosXcodeProjectsForSigningAndIdentity patches legacy ios/Happy.xcodeproj + ios/Happy/Info.plist', async () => {
+  const uiDir = await makeTempUiDir();
+  try {
+    const iosDir = join(uiDir, 'ios');
+    await mkdir(join(iosDir, 'Happy.xcodeproj'), { recursive: true });
+    await mkdir(join(iosDir, 'Happy'), { recursive: true });
+
+    const pbxprojPath = join(iosDir, 'Happy.xcodeproj', 'project.pbxproj');
+    await writeFile(
+      pbxprojPath,
+      [
+        'ProvisioningStyle = Automatic;',
+        'DEVELOPMENT_TEAM = 3RSYVV66F6;',
+        'CODE_SIGN_IDENTITY = "Apple Development";',
+        '"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";',
+        'PROVISIONING_PROFILE_SPECIFIER = some-profile;',
+        'PRODUCT_BUNDLE_IDENTIFIER = com.ex3ndr.happy;',
+        'PRODUCT_NAME = Happy;',
+        '',
+      ].join('\n'),
+      'utf-8'
+    );
+
+    const infoPlistPath = join(iosDir, 'Happy', 'Info.plist');
+    await writeFile(
+      infoPlistPath,
+      [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<plist version="1.0"><dict>',
+        '<key>CFBundleDisplayName</key><string>Happy</string>',
+        '</dict></plist>',
+        '',
+      ].join('\n'),
+      'utf-8'
+    );
+
+    await patchIosXcodeProjectsForSigningAndIdentity({
+      uiDir,
+      iosBundleId: 'com.happystacks.stack.user.pre-pr272',
+      iosAppName: 'HAPPY LEGACY',
+    });
+
+    const pbxproj = await readFile(pbxprojPath, 'utf-8');
+    assert.match(pbxproj, /PRODUCT_BUNDLE_IDENTIFIER = com\.happystacks\.stack\.user\.pre-pr272;/);
+    assert.ok(!pbxproj.includes('DEVELOPMENT_TEAM ='));
+    assert.ok(!pbxproj.includes('PROVISIONING_PROFILE_SPECIFIER ='));
+    assert.ok(!pbxproj.includes('CODE_SIGN_IDENTITY ='));
+    assert.match(pbxproj, /PRODUCT_NAME = HAPPY-LEGACY;/);
+
+    const plist = await readFile(infoPlistPath, 'utf-8');
+    assert.match(plist, /<key>CFBundleDisplayName<\/key><string>HAPPY LEGACY<\/string>/);
+  } finally {
+    await rm(uiDir, { recursive: true, force: true });
+  }
+});
+
+test('patchIosXcodeProjectsForSigningAndIdentity patches both Happydev + Happy projects when present', async () => {
+  const uiDir = await makeTempUiDir();
+  try {
+    const iosDir = join(uiDir, 'ios');
+
+    await mkdir(join(iosDir, 'Happy.xcodeproj'), { recursive: true });
+    await mkdir(join(iosDir, 'Happy'), { recursive: true });
+    await writeFile(join(iosDir, 'Happy.xcodeproj', 'project.pbxproj'), 'PRODUCT_BUNDLE_IDENTIFIER = com.ex3ndr.happy;\n', 'utf-8');
+    await writeFile(join(iosDir, 'Happy', 'Info.plist'), '<key>CFBundleDisplayName</key><string>Happy</string>\n', 'utf-8');
+
+    await mkdir(join(iosDir, 'Happydev.xcodeproj'), { recursive: true });
+    await mkdir(join(iosDir, 'Happydev'), { recursive: true });
+    await writeFile(join(iosDir, 'Happydev.xcodeproj', 'project.pbxproj'), 'PRODUCT_BUNDLE_IDENTIFIER = com.slopus.happy.dev;\n', 'utf-8');
+    await writeFile(join(iosDir, 'Happydev', 'Info.plist'), '<key>CFBundleDisplayName</key><string>Happy (dev)</string>\n', 'utf-8');
+
+    await patchIosXcodeProjectsForSigningAndIdentity({
+      uiDir,
+      iosBundleId: 'com.happystacks.stack.user.pre-pr272',
+      iosAppName: 'HAPPY LEGACY',
+    });
+
+    const pbxprojRelease = await readFile(join(iosDir, 'Happy.xcodeproj', 'project.pbxproj'), 'utf-8');
+    assert.match(pbxprojRelease, /PRODUCT_BUNDLE_IDENTIFIER = com\.happystacks\.stack\.user\.pre-pr272;/);
+
+    const pbxprojDev = await readFile(join(iosDir, 'Happydev.xcodeproj', 'project.pbxproj'), 'utf-8');
+    assert.match(pbxprojDev, /PRODUCT_BUNDLE_IDENTIFIER = com\.happystacks\.stack\.user\.pre-pr272;/);
+  } finally {
+    await rm(uiDir, { recursive: true, force: true });
+  }
+});

package/scripts/utils/net/lan_ip.mjs

@@ -0,0 +1,24 @@
+import { networkInterfaces } from 'node:os';
+
+export function pickLanIpv4() {
+  try {
+    const ifaces = networkInterfaces();
+    // Prefer en0 (typical Wi-Fi on macOS), then any non-internal IPv4.
+    const preferred = ['en0', 'en1', 'eth0', 'wlan0'];
+    for (const name of preferred) {
+      const list = ifaces[name] ?? [];
+      for (const i of list) {
+        if (i && i.family === 'IPv4' && !i.internal && i.address) return i.address;
+      }
+    }
+    for (const list of Object.values(ifaces)) {
+      for (const i of list ?? []) {
+        if (i && i.family === 'IPv4' && !i.internal && i.address) return i.address;
+      }
+    }
+  } catch {
+    // ignore
+  }
+  return '';
+}
+

package/scripts/utils/net/ports.mjs

@@ -2,7 +2,7 @@ import { setTimeout as delay } from 'node:timers/promises';
 import net from 'node:net';
 import { runCaptureIfCommandExists } from '../proc/commands.mjs';
 
-async function listListenPids(port) {
+export async function listListenPids(port) {
   if (!Number.isFinite(port) || port <= 0) return [];
   if (process.platform === 'win32') return [];
 
@@ -10,6 +10,14 @@ async function listListenPids(port) {
   try {
     // `lsof` exits non-zero if no matches; normalize to empty output.
     raw = await runCaptureIfCommandExists('lsof', ['-nP', `-iTCP:${port}`, '-sTCP:LISTEN', '-t']);
+    if (!raw && process.platform === 'darwin') {
+      // Some non-interactive shells (launchd/GUI apps) have a PATH that omits /usr/sbin,
+      // which makes `command -v lsof` fail even though lsof exists. Fall back to absolute paths.
+      raw =
+        (await runCaptureIfCommandExists('/usr/sbin/lsof', ['-nP', `-iTCP:${port}`, '-sTCP:LISTEN', '-t'])) ||
+        (await runCaptureIfCommandExists('/usr/bin/lsof', ['-nP', `-iTCP:${port}`, '-sTCP:LISTEN', '-t'])) ||
+        '';
+    }
   } catch {
     raw = '';
   }

package/scripts/utils/net/tcp_forward.mjs

@@ -0,0 +1,162 @@
+/**
+ * Lightweight TCP port forwarder using Node.js built-in `net` module.
+ *
+ * Used to expose Expo dev server (which binds to LAN IP) on the Tailscale interface,
+ * enabling remote device access over Tailscale without modifying Expo's binding behavior.
+ *
+ * Can be run standalone:
+ *   node tcp_forward.mjs --listen-host=100.x.y.z --listen-port=8081 --target-host=192.168.1.50 --target-port=8081
+ *
+ * Or imported and spawned as a managed child process.
+ */
+
+import net from 'node:net';
+
+/**
+ * Create a TCP forwarding server.
+ *
+ * @param {Object} options
+ * @param {string} options.listenHost - Host/IP to listen on (e.g., Tailscale IP)
+ * @param {number} options.listenPort - Port to listen on
+ * @param {string} options.targetHost - Host/IP to forward to (e.g., LAN IP or 127.0.0.1)
+ * @param {number} options.targetPort - Port to forward to
+ * @param {string} [options.label] - Label for logging (default: 'tcp-forward')
+ * @returns {net.Server}
+ */
+export function createTcpForwarder({ listenHost, listenPort, targetHost, targetPort, label = 'tcp-forward' }) {
+  const server = net.createServer((clientSocket) => {
+    const targetSocket = net.createConnection({ host: targetHost, port: targetPort }, () => {
+      // Connection established, pipe data both ways
+      clientSocket.pipe(targetSocket);
+      targetSocket.pipe(clientSocket);
+    });
+
+    // Handle errors on both sockets
+    clientSocket.on('error', (err) => {
+      if (err.code !== 'ECONNRESET') {
+        process.stderr.write(`[${label}] client error: ${err.message}\n`);
+      }
+      targetSocket.destroy();
+    });
+
+    targetSocket.on('error', (err) => {
+      if (err.code !== 'ECONNRESET' && err.code !== 'ECONNREFUSED') {
+        process.stderr.write(`[${label}] target error: ${err.message}\n`);
+      }
+      clientSocket.destroy();
+    });
+
+    // Clean up on close
+    clientSocket.on('close', () => targetSocket.destroy());
+    targetSocket.on('close', () => clientSocket.destroy());
+  });
+
+  server.on('error', (err) => {
+    process.stderr.write(`[${label}] server error: ${err.message}\n`);
+  });
+
+  return server;
+}
+
+/**
+ * Start a TCP forwarder and return a promise that resolves when listening.
+ *
+ * @param {Object} options - Same as createTcpForwarder
+ * @returns {Promise<{ server: net.Server, address: string, port: number }>}
+ */
+export async function startTcpForwarder(options) {
+  const { listenHost, listenPort, label = 'tcp-forward' } = options;
+  const server = createTcpForwarder(options);
+
+  return new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(listenPort, listenHost, () => {
+      server.removeListener('error', reject);
+      const addr = server.address();
+      const address = typeof addr === 'object' ? addr.address : listenHost;
+      const port = typeof addr === 'object' ? addr.port : listenPort;
+      process.stdout.write(`[${label}] forwarding ${address}:${port} -> ${options.targetHost}:${options.targetPort}\n`);
+      resolve({ server, address, port });
+    });
+  });
+}
+
+function trySendIpc(msg) {
+  try {
+    if (typeof process.send === 'function') {
+      process.send(msg);
+    }
+  } catch {
+    // ignore
+  }
+}
+
+/**
+ * Gracefully stop a TCP forwarder server.
+ *
+ * @param {net.Server} server
+ * @param {string} [label]
+ * @returns {Promise<void>}
+ */
+export async function stopTcpForwarder(server, label = 'tcp-forward') {
+  if (!server) return;
+  return new Promise((resolve) => {
+    server.close(() => {
+      process.stdout.write(`[${label}] stopped\n`);
+      resolve();
+    });
+    // Force-close after timeout
+    setTimeout(() => {
+      resolve();
+    }, 2000);
+  });
+}
+
+// Standalone CLI mode
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  const kv = new Map();
+  for (const arg of args) {
+    const m = arg.match(/^--([^=]+)=(.*)$/);
+    if (m) kv.set(m[1], m[2]);
+  }
+
+  const listenHost = kv.get('listen-host') || kv.get('listenHost');
+  const listenPort = Number(kv.get('listen-port') || kv.get('listenPort'));
+  const targetHost = kv.get('target-host') || kv.get('targetHost') || '127.0.0.1';
+  const targetPort = Number(kv.get('target-port') || kv.get('targetPort'));
+  const label = kv.get('label') || 'tcp-forward';
+
+  if (!listenHost || !listenPort || !targetPort) {
+    console.error('Usage: node tcp_forward.mjs --listen-host=<ip> --listen-port=<port> --target-host=<ip> --target-port=<port> [--label=<label>]');
+    process.exit(1);
+  }
+
+  const shutdown = () => {
+    process.stdout.write(`\n[${label}] shutting down...\n`);
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  startTcpForwarder({ listenHost, listenPort, targetHost, targetPort, label })
+    .then(() => {
+      trySendIpc({ type: 'ready', listenHost, listenPort, targetHost, targetPort, label });
+      // Keep running until signal
+    })
+    .catch((err) => {
+      trySendIpc({
+        type: 'error',
+        code: err && typeof err === 'object' ? err.code : null,
+        message: err instanceof Error ? err.message : String(err ?? 'unknown error'),
+        listenHost,
+        listenPort,
+        targetHost,
+        targetPort,
+        label,
+      });
+      console.error(`[${label}] failed to start: ${err.message}`);
+      process.exit(1);
+    });
+}

package/scripts/utils/net/url.mjs

@@ -0,0 +1,30 @@
+export function normalizeUrlNoTrailingSlash(raw) {
+  const s = String(raw ?? '').trim();
+  if (!s) return '';
+
+  let u;
+  try {
+    u = new URL(s);
+  } catch {
+    // Best-effort: if it's a plain string with trailing slash, trim it.
+    return s.endsWith('/') ? s.replace(/\/+$/, '') : s;
+  }
+
+  // Only normalize "base" URLs without search/hash.
+  // If search/hash is present, removing slashes can change semantics.
+  if (u.search || u.hash) {
+    return u.toString();
+  }
+
+  // Normalize multiple trailing slashes down to none (root) or one-less (non-root).
+  const path = u.pathname || '/';
+  if (path === '/' || path === '') {
+    return u.origin;
+  }
+  if (path.endsWith('/')) {
+    const nextPath = path.replace(/\/+$/, '');
+    return `${u.origin}${nextPath}`;
+  }
+  return u.toString();
+}
+

package/scripts/utils/net/url.test.mjs

@@ -0,0 +1,20 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { normalizeUrlNoTrailingSlash } from './url.mjs';
+
+test('normalizeUrlNoTrailingSlash removes trailing slash from origins', () => {
+  assert.equal(normalizeUrlNoTrailingSlash('https://example.com/'), 'https://example.com');
+  assert.equal(normalizeUrlNoTrailingSlash('http://localhost:3005/'), 'http://localhost:3005');
+});
+
+test('normalizeUrlNoTrailingSlash removes trailing slash from path-only base URLs', () => {
+  assert.equal(normalizeUrlNoTrailingSlash('https://example.com/api/'), 'https://example.com/api');
+  assert.equal(normalizeUrlNoTrailingSlash('https://example.com/api///'), 'https://example.com/api');
+});
+
+test('normalizeUrlNoTrailingSlash preserves query/hash URLs', () => {
+  assert.equal(normalizeUrlNoTrailingSlash('https://example.com/?q=1'), 'https://example.com/?q=1');
+  assert.equal(normalizeUrlNoTrailingSlash('https://example.com/api/?q=1'), 'https://example.com/api/?q=1');
+});
+

package/scripts/utils/paths/localhost_host.mjs

@@ -1,9 +1,56 @@
 import { getStackName } from './paths.mjs';
 import { sanitizeDnsLabel } from '../net/dns.mjs';
 
-export function resolveLocalhostHost({ stackMode, stackName = getStackName() } = {}) {
+export function resolveLocalhostHost({ stackMode, stackName = null, env = process.env } = {}) {
+  const name = (stackName ?? '').toString().trim() || getStackName(env);
   if (!stackMode) return 'localhost';
-  if (!stackName || stackName === 'main') return 'localhost';
-  return `happy-${sanitizeDnsLabel(stackName)}.localhost`;
+  if (!name || name === 'main') return 'localhost';
+  return `happy-${sanitizeDnsLabel(name)}.localhost`;
+}
+
+export async function preferStackLocalhostHost({ stackName = null, env = process.env } = {}) {
+  const name = (stackName ?? '').toString().trim() || getStackName(env);
+  if (!name || name === 'main') return 'localhost';
+  // IMPORTANT:
+  // We intentionally do NOT gate on `dns.lookup()` here.
+  //
+  // On some systems (notably macOS), Node's DNS resolver may return ENOTFOUND for `*.localhost`
+  // even though browsers treat `*.localhost` as loopback and will load it fine.
+  //
+  // Since this hostname is primarily used for browser-facing URLs and origin isolation, we
+  // prefer the stable `happy-<stack>.localhost` form by default and allow opting out via env.
+  const modeRaw = (env.HAPPY_STACKS_LOCALHOST_SUBDOMAINS ?? env.HAPPY_LOCAL_LOCALHOST_SUBDOMAINS ?? '')
+    .toString()
+    .trim()
+    .toLowerCase();
+  const disabled = modeRaw === '0' || modeRaw === 'false' || modeRaw === 'no' || modeRaw === 'off';
+  if (disabled) return 'localhost';
+
+  const preferredHost = resolveLocalhostHost({ stackMode: true, stackName: name, env });
+  return preferredHost || 'localhost';
+}
+
+// Best-effort: for stacks, prefer `happy-<stack>.localhost` over `localhost` when it's reachable.
+// This keeps URLs stable and stack-scoped while still failing closed to plain localhost.
+export async function preferStackLocalhostUrl(url, { stackName = null, env = process.env } = {}) {
+  const raw = String(url ?? '').trim();
+  if (!raw) return '';
+  const name = (stackName ?? '').toString().trim() || getStackName(env);
+  if (!name || name === 'main') return raw;
+
+  let u = null;
+  try {
+    u = new URL(raw);
+  } catch {
+    return raw;
+  }
+  if (u.protocol !== 'http:' && u.protocol !== 'https:') return raw;
+
+  const isLoopbackHost = u.hostname === 'localhost' || u.hostname === '127.0.0.1';
+  if (!isLoopbackHost) return raw;
+
+  const preferredHost = await preferStackLocalhostHost({ stackName: name, env });
+  if (!preferredHost || preferredHost === 'localhost') return raw;
+  return raw.replace(`://${u.hostname}`, `://${preferredHost}`);
 }