happy-stacks 0.0.0

package/scripts/mobile.mjs

@@ -0,0 +1,305 @@
+import './utils/env.mjs';
+import { parseArgs } from './utils/args.mjs';
+import { killPortListeners } from './utils/ports.mjs';
+import { run, runCapture, spawnProc } from './utils/proc.mjs';
+import { getComponentDir, getRootDir } from './utils/paths.mjs';
+import { ensureDepsInstalled, requireDir } from './utils/pm.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
+
+/**
+ * Mobile dev helper for the embedded `components/happy` Expo app.
+ *
+ * Goals:
+ * - Avoid editing upstream config files in-place.
+ * - Ensure the QR/deeplink opens the *dev build* even if the App Store app is installed.
+ *
+ * Usage:
+ *   happys mobile
+ *   happys mobile --host=lan
+ *   happys mobile --scheme=com.slopus.happy.dev
+  *   happys mobile --no-metro
+ *   happys mobile --run-ios --device="Your iPhone"
+ */
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const { flags, kv } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+
+  if (wantsHelp(argv, { flags })) {
+    printResult({
+      json,
+      data: {
+        flags: [
+          '--host=lan|localhost|tunnel',
+          '--port=8081',
+          '--scheme=<url-scheme>',
+          '--ios-bundle-id=<bundle-id>',
+          '--ios-app-name=<name>',
+          '--app-env=development|production',
+          '--prebuild [--platform=ios|all] [--clean]',
+          '--run-ios [--device=<id-or-name>] [--configuration=Debug|Release]',
+          '--metro / --no-metro',
+          '--no-signing-fix',
+        ],
+        json: true,
+      },
+      text: [
+        '[mobile] usage:',
+        '  happys mobile [--host=lan|localhost|tunnel] [--port=8081] [--scheme=...] [--json]',
+        '  happys mobile --run-ios [--device=...] [--configuration=Debug|Release]',
+        '  happys mobile --prebuild [--platform=ios|all] [--clean]',
+        '  happys mobile --no-metro   # just build/install (if --run-ios) without starting Metro',
+        '',
+        'Notes:',
+        '- This script is designed to avoid editing upstream `components/happy` config in-place.',
+        '- It sets EXPO_PUBLIC_HAPPY_SERVER_URL from HAPPY_STACKS_SERVER_URL (legacy: HAPPY_LOCAL_SERVER_URL) if provided.',
+      ].join('\n'),
+    });
+    return;
+  }
+
+  const rootDir = getRootDir(import.meta.url);
+  const uiDir = getComponentDir(rootDir, 'happy');
+  await requireDir('happy', uiDir);
+  await ensureDepsInstalled(uiDir, 'happy');
+
+  const sanitizeBundleIdSegment = (s) =>
+    (s ?? '')
+      .toString()
+      .trim()
+      .toLowerCase()
+      .replace(/[^a-z0-9-]+/g, '-')
+      .replace(/^-+|-+$/g, '') || 'user';
+
+  const defaultLocalBundleId = (() => {
+    const user = sanitizeBundleIdSegment(process.env.USER ?? process.env.USERNAME ?? 'user');
+    return `com.happy.local.${user}.dev`;
+  })();
+
+  async function readXcdeviceList() {
+    if (process.platform !== 'darwin') {
+      return [];
+    }
+    const raw = await runCapture('xcrun', ['xcdevice', 'list'], { cwd: uiDir, env: process.env });
+    const start = raw.indexOf('[');
+    const jsonText = start >= 0 ? raw.slice(start) : raw;
+    const parsed = JSON.parse(jsonText);
+    return Array.isArray(parsed) ? parsed : [];
+  }
+
+  // Default to the existing dev bundle identifier, which is also registered as a URL scheme
+  // (Info.plist includes `com.slopus.happy.dev`), so iOS will open the dev build instead of the App Store app.
+  const appEnv = process.env.APP_ENV ?? kv.get('--app-env') ?? 'development';
+  const iosAppName =
+    kv.get('--ios-app-name') ??
+    process.env.HAPPY_STACKS_IOS_APP_NAME ??
+    process.env.HAPPY_LOCAL_IOS_APP_NAME ??
+    '';
+  const iosBundleId =
+    kv.get('--ios-bundle-id') ??
+    process.env.HAPPY_STACKS_IOS_BUNDLE_ID ??
+    process.env.HAPPY_LOCAL_IOS_BUNDLE_ID ??
+    defaultLocalBundleId;
+  const scheme =
+    kv.get('--scheme') ??
+    process.env.HAPPY_STACKS_MOBILE_SCHEME ??
+    process.env.HAPPY_LOCAL_MOBILE_SCHEME ??
+    iosBundleId;
+  const host = kv.get('--host') ?? process.env.HAPPY_STACKS_MOBILE_HOST ?? process.env.HAPPY_LOCAL_MOBILE_HOST ?? 'lan';
+  const port = kv.get('--port') ?? process.env.HAPPY_STACKS_MOBILE_PORT ?? process.env.HAPPY_LOCAL_MOBILE_PORT ?? '8081';
+  // Default behavior:
+  // - `happys mobile` starts Metro and keeps running.
+  // - `happys mobile --run-ios` / `happys mobile:ios` just builds/installs and exits (unless --metro is provided).
+  const shouldStartMetro =
+    flags.has('--metro') ||
+    (!flags.has('--no-metro') && !flags.has('--run-ios') && !flags.has('--prebuild'));
+
+  const env = {
+    ...process.env,
+    APP_ENV: appEnv,
+  };
+
+  // Allow happy-stacks to define the default server URL baked into the app bundle.
+  // This is read by the app via `process.env.EXPO_PUBLIC_HAPPY_SERVER_URL`.
+  const stacksServerUrl =
+    process.env.HAPPY_STACKS_SERVER_URL?.trim() || process.env.HAPPY_LOCAL_SERVER_URL?.trim() || '';
+  if (stacksServerUrl && !env.EXPO_PUBLIC_HAPPY_SERVER_URL) {
+    env.EXPO_PUBLIC_HAPPY_SERVER_URL = stacksServerUrl;
+  }
+
+  if (json) {
+    printResult({
+      json,
+      data: {
+        ok: true,
+        uiDir,
+        appEnv,
+        iosAppName,
+        iosBundleId,
+        scheme,
+        host,
+        port,
+        shouldPrebuild: flags.has('--prebuild'),
+        shouldRunIos: flags.has('--run-ios'),
+        shouldStartMetro,
+        expoPublicHappyServerUrl: env.EXPO_PUBLIC_HAPPY_SERVER_URL ?? '',
+      },
+    });
+    return;
+  }
+
+  const shouldPrebuild = flags.has('--prebuild');
+  if (shouldPrebuild) {
+    const platform = kv.get('--platform') ?? 'ios';
+    const shouldClean = flags.has('--clean');
+    // Prebuild can fail during `pod install` if deployment target mismatches.
+    // We skip installs, patch deployment target + RN build mode, then run `pod install` ourselves.
+    const prebuildArgs = ['expo', 'prebuild', '--no-install', '--platform', platform];
+    if (shouldClean) {
+      prebuildArgs.push('--clean');
+    }
+    await run('npx', prebuildArgs, { cwd: uiDir, env });
+
+    // Always patch iOS props if iOS was generated.
+    if (platform === 'ios' || platform === 'all') {
+      const fs = await import('node:fs/promises');
+      const podPropsPath = `${uiDir}/ios/Podfile.properties.json`;
+      const pbxprojPath = `${uiDir}/ios/Happydev.xcodeproj/project.pbxproj`;
+      try {
+        const raw = await fs.readFile(podPropsPath, 'utf-8');
+        const json = JSON.parse(raw);
+        json['ios.deploymentTarget'] = '16.0';
+        json['ios.buildReactNativeFromSource'] = 'true';
+        await fs.writeFile(podPropsPath, JSON.stringify(json, null, 2) + '\n', 'utf-8');
+      } catch {
+        // ignore if path missing (platform != ios)
+      }
+
+      try {
+        const raw = await fs.readFile(pbxprojPath, 'utf-8');
+        const next = raw.replaceAll('IPHONEOS_DEPLOYMENT_TARGET = 15.1;', 'IPHONEOS_DEPLOYMENT_TARGET = 16.0;');
+        if (next !== raw) {
+          await fs.writeFile(pbxprojPath, next, 'utf-8');
+        }
+      } catch {
+        // ignore missing pbxproj (unexpected)
+      }
+
+      // Ensure CocoaPods doesn't crash due to locale issues.
+      env.LANG = env.LANG ?? 'en_US.UTF-8';
+      env.LC_ALL = env.LC_ALL ?? 'en_US.UTF-8';
+      await run('sh', ['-lc', 'cd ios && pod install'], { cwd: uiDir, env });
+    }
+  }
+
+  if (flags.has('--run-ios')) {
+    let device = kv.get('--device') ?? '';
+    let resolvedDevice = null;
+    if (process.platform === 'darwin') {
+      try {
+        const list = await readXcdeviceList();
+        resolvedDevice = device
+          ? list.find((d) => d && (d.identifier === device || d.name === device)) ?? null
+          : null;
+      } catch {
+        resolvedDevice = null;
+      }
+    }
+
+    if (!device && process.platform === 'darwin') {
+      // Auto-pick a connected physical iPhone/iPad if available.
+      // This avoids needing to know the exact "Your iPhone" string.
+      try {
+        const list = await readXcdeviceList();
+        const firstConnectedIosDevice = Array.isArray(list)
+          ? list.find(
+              (d) =>
+                d &&
+                d.platform === 'com.apple.platform.iphoneos' &&
+                d.interface === 'usb' &&
+                (d.available === true || d.available === 'YES') &&
+                typeof d.identifier === 'string' &&
+                d.identifier.length > 0
+            )
+          : null;
+        if (firstConnectedIosDevice?.identifier) {
+          device = firstConnectedIosDevice.identifier;
+          resolvedDevice = firstConnectedIosDevice;
+          // eslint-disable-next-line no-console
+          console.log(`[mobile] using connected device: ${firstConnectedIosDevice.name} (${device})`);
+        }
+      } catch {
+        // ignore and let Expo choose
+      }
+    }
+
+    const isPhysicalIosDevice =
+      resolvedDevice?.platform === 'com.apple.platform.iphoneos' && resolvedDevice?.simulator === false;
+
+    const shouldPatchXcodeProject = isPhysicalIosDevice || !!iosAppName;
+    if (shouldPatchXcodeProject && !flags.has('--no-signing-fix')) {
+      // Expo CLI only passes `-allowProvisioningUpdates` when it *needs* to configure signing.
+      // If the pbxproj already has a DEVELOPMENT_TEAM set but no local provisioning profile exists yet,
+      // xcodebuild fails with:
+      //   "Automatic signing is disabled ... pass -allowProvisioningUpdates"
+      //
+      // We force Expo CLI to go through its signing configuration path by clearing DEVELOPMENT_TEAM,
+      // so it will re-set the team and include the provisioning flags.
+      try {
+        const fs = await import('node:fs/promises');
+        const pbxprojPath = `${uiDir}/ios/Happydev.xcodeproj/project.pbxproj`;
+        const raw = await fs.readFile(pbxprojPath, 'utf-8');
+        let next = raw.replaceAll(/^\s*DEVELOPMENT_TEAM = ".*";\s*$/gm, '');
+        next = next.replaceAll(/PRODUCT_BUNDLE_IDENTIFIER = [^;]+;/g, `PRODUCT_BUNDLE_IDENTIFIER = ${iosBundleId};`);
+        if (iosAppName && iosAppName.trim()) {
+          const name = iosAppName.trim();
+          const quoted = name.includes(' ') || name.includes('"') ? `"${name.replaceAll('"', '\\"')}"` : name;
+          next = next.replaceAll(/PRODUCT_NAME = [^;]+;/g, `PRODUCT_NAME = ${quoted};`);
+        }
+        if (next !== raw) {
+          await fs.writeFile(pbxprojPath, next, 'utf-8');
+        }
+      } catch {
+        // ignore
+      }
+    }
+
+    const configuration = kv.get('--configuration') ?? 'Debug';
+    const args = ['expo', 'run:ios', '--no-bundler', '--no-build-cache', '--configuration', configuration];
+    if (device) {
+      args.push('-d', device);
+    }
+    // Ensure CocoaPods doesn't crash due to locale issues.
+    env.LANG = env.LANG ?? 'en_US.UTF-8';
+    env.LC_ALL = env.LC_ALL ?? 'en_US.UTF-8';
+    await run('npx', args, { cwd: uiDir, env });
+  }
+
+  if (!shouldStartMetro) {
+    return;
+  }
+
+  const portNumber = Number.parseInt(port, 10);
+  if (Number.isFinite(portNumber) && portNumber > 0) {
+    await killPortListeners(portNumber, { label: 'expo' });
+  }
+
+  // Start Metro for a dev client.
+  // The critical part is --scheme: without it, Expo defaults to `exp+<slug>` (here `exp+happy`)
+  // which the App Store app also registers, so iOS can open the wrong app.
+  spawnProc(
+    'mobile',
+    'npx',
+    ['expo', 'start', '--dev-client', '--host', host, '--port', port, '--scheme', scheme],
+    env,
+    { cwd: uiDir }
+  );
+
+  await new Promise(() => {});
+}
+
+main().catch((err) => {
+  console.error('[mobile] failed:', err);
+  process.exit(1);
+});

package/scripts/run.mjs

@@ -0,0 +1,236 @@
+import './utils/env.mjs';
+import { parseArgs } from './utils/args.mjs';
+import { pathExists } from './utils/fs.mjs';
+import { killProcessTree, runCapture } from './utils/proc.mjs';
+import { getComponentDir, getDefaultAutostartPaths, getRootDir } from './utils/paths.mjs';
+import { killPortListeners } from './utils/ports.mjs';
+import { getServerComponentName, waitForServerReady } from './utils/server.mjs';
+import { pmSpawnScript, requireDir } from './utils/pm.mjs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { maybeResetTailscaleServe, resolvePublicServerUrl } from './tailscale.mjs';
+import { startLocalDaemonWithAuth, stopLocalDaemon } from './daemon.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
+import { assertServerComponentDirMatches } from './utils/validate.mjs';
+
+/**
+ * Run the local stack in "production-like" mode:
+ * - happy-server-light
+ * - happy-cli daemon
+ * - serve prebuilt UI via happy-server-light (/)
+ *
+ * No Expo dev server.
+ */
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const { flags, kv } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+  if (wantsHelp(argv, { flags })) {
+    printResult({
+      json,
+      data: { flags: ['--server=happy-server|happy-server-light', '--no-ui', '--no-daemon'], json: true },
+      text: [
+        '[start] usage:',
+        '  happys start [--server=happy-server|happy-server-light] [--json]',
+        '  (legacy in a cloned repo): pnpm start [-- --server=happy-server|happy-server-light] [--json]',
+        '  note: --json prints the resolved config (dry-run) and exits.',
+      ].join('\n'),
+    });
+    return;
+  }
+
+  const rootDir = getRootDir(import.meta.url);
+
+  const serverPort = process.env.HAPPY_LOCAL_SERVER_PORT
+    ? parseInt(process.env.HAPPY_LOCAL_SERVER_PORT, 10)
+    : 3005;
+
+  // Internal URL used by local processes on this machine.
+  const internalServerUrl = `http://127.0.0.1:${serverPort}`;
+  // Public URL is what you might share/open (e.g. https://<machine>.<tailnet>.ts.net).
+  // We auto-prefer the Tailscale HTTPS URL when available, unless explicitly overridden.
+  const defaultPublicUrl = `http://localhost:${serverPort}`;
+  const envPublicUrl = process.env.HAPPY_LOCAL_SERVER_URL?.trim() ? process.env.HAPPY_LOCAL_SERVER_URL.trim() : '';
+  let publicServerUrl = envPublicUrl || defaultPublicUrl;
+
+  const serverComponentName = getServerComponentName({ kv });
+  if (serverComponentName === 'both') {
+    throw new Error(`[local] --server=both is not supported for run (pick one: happy-server-light or happy-server)`);
+  }
+
+  const startDaemon = !flags.has('--no-daemon') && (process.env.HAPPY_LOCAL_DAEMON ?? '1') !== '0';
+  const serveUiWanted = !flags.has('--no-ui') && (process.env.HAPPY_LOCAL_SERVE_UI ?? '1') !== '0';
+  const serveUi = serveUiWanted && serverComponentName === 'happy-server-light';
+  const uiPrefix = process.env.HAPPY_LOCAL_UI_PREFIX?.trim() ? process.env.HAPPY_LOCAL_UI_PREFIX.trim() : '/';
+  const uiBuildDir = process.env.HAPPY_LOCAL_UI_BUILD_DIR?.trim()
+    ? process.env.HAPPY_LOCAL_UI_BUILD_DIR.trim()
+    : join(getDefaultAutostartPaths().baseDir, 'ui');
+
+  const enableTailscaleServe = (process.env.HAPPY_LOCAL_TAILSCALE_SERVE ?? '0') === '1';
+
+  const serverDir = getComponentDir(rootDir, serverComponentName);
+  const cliDir = getComponentDir(rootDir, 'happy-cli');
+
+  assertServerComponentDirMatches({ rootDir, serverComponentName, serverDir });
+
+  await requireDir(serverComponentName, serverDir);
+  await requireDir('happy-cli', cliDir);
+
+  const cliBin = join(cliDir, 'bin', 'happy.mjs');
+
+  const cliHomeDir = process.env.HAPPY_LOCAL_CLI_HOME_DIR?.trim()
+    ? process.env.HAPPY_LOCAL_CLI_HOME_DIR.trim().replace(/^~(?=\/)/, homedir())
+    : join(getDefaultAutostartPaths().baseDir, 'cli');
+
+  if (json) {
+    printResult({
+      json,
+      data: {
+        mode: 'start',
+        serverComponentName,
+        serverDir,
+        cliDir,
+        serverPort,
+        internalServerUrl,
+        publicServerUrl,
+        startDaemon,
+        serveUi,
+        uiPrefix,
+        uiBuildDir,
+        cliHomeDir,
+      },
+    });
+    return;
+  }
+
+  if (serveUiWanted && !serveUi) {
+    console.log(`[local] ui serving disabled (requires happy-server-light; you are using ${serverComponentName})`);
+  }
+
+  if (serveUi && !(await pathExists(uiBuildDir))) {
+    throw new Error(`[local] UI build directory not found at ${uiBuildDir}. Run: happys build (legacy in a cloned repo: pnpm build)`);
+  }
+
+  const children = [];
+  let shuttingDown = false;
+  const baseEnv = { ...process.env };
+
+  // Public URL automation: auto-prefer https://*.ts.net on every start.
+  const resolved = await resolvePublicServerUrl({
+    internalServerUrl,
+    defaultPublicUrl,
+    envPublicUrl,
+    allowEnable: true,
+  });
+  publicServerUrl = resolved.publicServerUrl;
+
+  // Server
+  // If a previous run left a server behind, free the port first (prevents false "ready" checks).
+  await killPortListeners(serverPort, { label: 'server' });
+
+  const serverEnv = {
+    ...baseEnv,
+    PORT: String(serverPort),
+    // Used by server-light for generating public file URLs.
+    PUBLIC_URL: publicServerUrl,
+    // Avoid noisy failures if a previous run left the metrics port busy.
+    // You can override with METRICS_ENABLED=true if you want it.
+    METRICS_ENABLED: baseEnv.METRICS_ENABLED ?? 'false',
+    ...(serveUi
+      ? {
+          HAPPY_SERVER_LIGHT_UI_DIR: uiBuildDir,
+          HAPPY_SERVER_LIGHT_UI_PREFIX: uiPrefix,
+        }
+      : {}),
+  };
+
+  const server = await pmSpawnScript({ label: 'server', dir: serverDir, script: 'dev', env: serverEnv });
+  children.push(server);
+
+  await waitForServerReady(internalServerUrl);
+  console.log(`[local] server ready at ${internalServerUrl}`);
+
+  if (enableTailscaleServe) {
+    try {
+      const status = await runCapture(process.execPath, [join(rootDir, 'scripts', 'tailscale.mjs'), 'status']);
+      const line = status.split('\n').find((l) => l.toLowerCase().includes('https://'))?.trim();
+      if (line) {
+        console.log(`[local] tailscale serve: ${line}`);
+      } else {
+        console.log('[local] tailscale serve enabled');
+      }
+    } catch {
+      console.log('[local] tailscale serve enabled');
+    }
+  }
+
+  if (serveUi) {
+    const localUi = internalServerUrl.replace(/\/+$/, '') + '/';
+    console.log(`[local] ui served locally at ${localUi}`);
+    if (publicServerUrl && publicServerUrl !== internalServerUrl && publicServerUrl !== localUi && publicServerUrl !== defaultPublicUrl) {
+      const pubUi = publicServerUrl.replace(/\/+$/, '') + '/';
+      console.log(`[local] public url: ${pubUi}`);
+    }
+    if (enableTailscaleServe) {
+      console.log('[local] tip: use the HTTPS *.ts.net URL for remote access');
+    }
+
+    console.log(
+      `[local] tip: to run 'happy' from your terminal *against this local server* (and have sessions show up in the UI), use:\n` +
+      `export HAPPY_SERVER_URL=\"${internalServerUrl}\"\n` +
+      `export HAPPY_HOME_DIR=\"${cliHomeDir}\"\n` +
+      `export HAPPY_WEBAPP_URL=\"${publicServerUrl}\"\n`
+    );
+  }
+
+  // Daemon
+  if (startDaemon) {
+    await startLocalDaemonWithAuth({
+      cliBin,
+      cliHomeDir,
+      internalServerUrl,
+      publicServerUrl,
+      isShuttingDown: () => shuttingDown,
+    });
+  }
+
+  const shutdown = async () => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    console.log('\n[local] shutting down...');
+
+    if (startDaemon) {
+      await stopLocalDaemon({ cliBin, internalServerUrl, cliHomeDir });
+    }
+
+    for (const child of children) {
+      if (child.exitCode == null) {
+        killProcessTree(child, 'SIGINT');
+      }
+    }
+
+    await delay(1500);
+    for (const child of children) {
+      if (child.exitCode == null) {
+        killProcessTree(child, 'SIGKILL');
+      }
+    }
+
+    await maybeResetTailscaleServe();
+  };
+
+  process.on('SIGINT', () => shutdown().then(() => process.exit(0)));
+  process.on('SIGTERM', () => shutdown().then(() => process.exit(0)));
+
+  // Keep running
+  await new Promise(() => {});
+}
+
+main().catch((err) => {
+  console.error('[local] failed:', err);
+  process.exit(1);
+});