happy-stacks 0.4.0 → 0.5.0

package/scripts/dev.mjs

@@ -17,7 +17,7 @@ import { resolveStackContext } from './utils/stack/context.mjs';
 import { resolveServerPortFromEnv, resolveServerUrls } from './utils/server/urls.mjs';
 import { ensureDevCliReady, prepareDaemonAuthSeed, startDevDaemon, watchHappyCliAndRestartDaemon } from './utils/dev/daemon.mjs';
 import { startDevServer, watchDevServerAndRestart } from './utils/dev/server.mjs';
-import { ensureDevExpoServer } from './utils/dev/expo_dev.mjs';
+import { ensureDevExpoServer, resolveExpoTailscaleEnabled } from './utils/dev/expo_dev.mjs';
 import { preferStackLocalhostUrl } from './utils/paths/localhost_host.mjs';
 import { openUrlInBrowser } from './utils/ui/browser.mjs';
 import { waitForHttpOk } from './utils/server/server.mjs';
@@ -41,18 +41,22 @@ async function main() {
   if (wantsHelp(argv, { flags })) {
     printResult({
       json,
-      data: { flags: ['--server=happy-server|happy-server-light', '--no-ui', '--no-daemon', '--restart', '--watch', '--no-watch', '--no-browser', '--mobile'], json: true },
+      data: { flags: ['--server=happy-server|happy-server-light', '--no-ui', '--no-daemon', '--restart', '--watch', '--no-watch', '--no-browser', '--mobile', '--expo-tailscale'], json: true },
       text: [
         '[dev] usage:',
         '  happys dev [--server=happy-server|happy-server-light] [--restart] [--json]',
-        '  happys dev --watch      # rebuild/restart happy-cli daemon on file changes (TTY default)',
-        '  happys dev --no-watch   # disable watch mode (always disabled in non-interactive mode)',
-        '  happys dev --no-browser # do not open the UI in your browser automatically',
-        '  happys dev --mobile     # also start Expo dev-client Metro for mobile',
+        '  happys dev --watch         # rebuild/restart happy-cli daemon on file changes (TTY default)',
+        '  happys dev --no-watch      # disable watch mode (always disabled in non-interactive mode)',
+        '  happys dev --no-browser    # do not open the UI in your browser automatically',
+        '  happys dev --mobile        # also start Expo dev-client Metro for mobile',
+        '  happys dev --expo-tailscale # forward Expo to Tailscale interface for remote access',
         '  note: --json prints the resolved config (dry-run) and exits.',
         '',
         'note:',
         '  If run from inside a component checkout/worktree, that checkout is used for this run (without requiring `happys wt use`).',
+        '',
+        'env:',
+        '  HAPPY_STACKS_EXPO_TAILSCALE=1   # enable Expo Tailscale forwarding via env var',
       ].join('\n'),
     });
     return;
@@ -82,6 +86,7 @@ async function main() {
   const startDaemon = !flags.has('--no-daemon') && (process.env.HAPPY_LOCAL_DAEMON ?? '1') !== '0';
   const startMobile = flags.has('--mobile') || flags.has('--with-mobile');
   const noBrowser = flags.has('--no-browser') || (process.env.HAPPY_STACKS_NO_BROWSER ?? process.env.HAPPY_LOCAL_NO_BROWSER ?? '').toString().trim() === '1';
+  const expoTailscale = flags.has('--expo-tailscale') || resolveExpoTailscaleEnabled({ env: process.env });
 
   const serverDir = getComponentDir(rootDir, serverComponentName);
   const uiDir = getComponentDir(rootDir, 'happy');
@@ -231,7 +236,7 @@ async function main() {
   );
 
   // Reliability before daemon start:
-  // - Ensure schema exists (server-light: db push; happy-server: migrate deploy if tables missing)
+  // - Ensure schema exists (server-light: prisma migrate deploy; happy-server: migrate deploy if tables missing)
   // - Auto-seed from main only when needed (non-main + non-interactive default, and only if missing creds or 0 accounts)
   const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
   const accountProbe = await getAccountCountForServerComponent({
@@ -267,6 +272,7 @@ async function main() {
       envPath,
       children,
       spawnOptions: { stdio: ['ignore', 'ignore', 'ignore'] },
+      expoTailscale,
     });
   }
   await maybeRunInteractiveStackAuthSetup({
@@ -300,6 +306,7 @@ async function main() {
         stackName,
         envPath,
         children,
+        expoTailscale,
       });
     },
   });
@@ -404,6 +411,7 @@ async function main() {
       stackName,
       envPath,
       children,
+      expoTailscale,
     }));
   if (startUi) {
     const uiPort = expoRes?.port;
@@ -435,6 +443,11 @@ async function main() {
     console.log(`[local] mobile: metro ${metroUrl}`);
   }
 
+  // Show Tailscale URL if forwarder is running
+  if (expoRes?.tailscale?.ok && expoRes.tailscale.tailscaleIp && expoRes.port) {
+    console.log(`[local] expo tailscale: http://${expoRes.tailscale.tailscaleIp}:${expoRes.port}`);
+  }
+
   const shutdown = async () => {
     if (shuttingDown) {
       return;

package/scripts/doctor.mjs

@@ -202,10 +202,6 @@ async function main() {
 
   // UI build dir check
   if (serveUi) {
-    if (serverComponentName !== 'happy-server-light') {
-      report.checks.uiServing = { ok: false, reason: `requires happy-server-light (current: ${serverComponentName})` };
-      if (!json) console.log(`ℹ️ ui serving requires happy-server-light (current: ${serverComponentName})`);
-    }
     if (await pathExists(uiBuildDir)) {
       report.checks.uiBuildDir = { ok: true, path: uiBuildDir };
       if (!json) console.log('✅ ui build dir present');

package/scripts/edison.mjs

@@ -14,6 +14,7 @@ import { join } from 'node:path';
 import { spawn } from 'node:child_process';
 import { mkdir, lstat, rename, symlink, writeFile, readdir, chmod } from 'node:fs/promises';
 import os from 'node:os';
+import { normalizeGitRoots } from './utils/edison/git_roots.mjs';
 
 const COMPONENTS = ['happy', 'happy-cli', 'happy-server-light', 'happy-server'];
 
@@ -1343,7 +1344,7 @@ async function resolveFingerprintGitRoots({ rootDir, stackEnv, edisonArgs }) {
     const d = resolveComponentDirFromStackEnv({ rootDir, stackEnv, component: c });
     if (d) dirs.push(d);
   }
-  return dirs.length ? dirs : fallback;
+  return normalizeGitRoots(dirs.length ? dirs : fallback);
 }
 
 async function cmdTrackCoherence({ rootDir, argv, json }) {
@@ -1852,4 +1853,3 @@ main().catch((err) => {
   console.error('[edison] failed:', err);
   process.exit(1);
 });
-

package/scripts/env.mjs

@@ -0,0 +1,150 @@
+import './utils/env/env.mjs';
+import { parseArgs } from './utils/cli/args.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
+import { ensureEnvFilePruned, ensureEnvFileUpdated } from './utils/env/env_file.mjs';
+import { parseEnvToObject } from './utils/env/dotenv.mjs';
+import { resolveStackEnvPath } from './utils/paths/paths.mjs';
+import { readTextOrEmpty } from './utils/fs/ops.mjs';
+
+function resolveTargetEnvPath() {
+  // If we're already running under a stack wrapper, respect it.
+  const explicit = (process.env.HAPPY_STACKS_ENV_FILE ?? process.env.HAPPY_LOCAL_ENV_FILE ?? '').trim();
+  if (explicit) return explicit;
+
+  // Self-host default: no stacks knowledge required; persist in the main stack env file.
+  return resolveStackEnvPath('main').envPath;
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const { flags } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+
+  const helpText = [
+    '[env] usage:',
+    '  happys env set KEY=VALUE [KEY2=VALUE2...]',
+    '  happys env unset KEY [KEY2...]',
+    '  happys env get KEY',
+    '  happys env list',
+    '  happys env path',
+    '',
+    'defaults:',
+    '  - If running under a stack wrapper (HAPPY_STACKS_ENV_FILE is set), edits that stack env file.',
+    '  - Otherwise, edits the main stack env file (~/.happy/stacks/main/env).',
+    '',
+    'notes:',
+    '  - Changes take effect on next stack/daemon start (restart to apply).',
+  ].join('\n');
+
+  if (wantsHelp(argv, { flags })) {
+    printResult({
+      json,
+      data: {
+        usage:
+          'happys env set KEY=VALUE [KEY2=VALUE2...] | unset KEY [KEY2...] | get KEY | list | path [--json]',
+      },
+      text: helpText,
+    });
+    return;
+  }
+
+  const positionals = argv.filter((a) => !a.startsWith('--'));
+  const subcmd = (positionals[0] ?? '').trim() || 'help';
+  const envPath = resolveTargetEnvPath();
+
+  if (subcmd === 'help') {
+    printResult({
+      json,
+      data: {
+        usage: 'happys env set|unset|get|list|path [--json]',
+      },
+      text: helpText,
+    });
+    return;
+  }
+
+  if (subcmd === 'path') {
+    printResult({
+      json,
+      data: { ok: true, envPath },
+      text: envPath,
+    });
+    return;
+  }
+
+  const raw = await readTextOrEmpty(envPath);
+  const parsed = parseEnvToObject(raw);
+
+  if (subcmd === 'list') {
+    const keys = Object.keys(parsed ?? {}).sort((a, b) => a.localeCompare(b));
+    const text = [
+      `[env] path: ${envPath}`,
+      ...keys.map((k) => `${k}=${parsed[k] ?? ''}`),
+    ].join('\n');
+    printResult({ json, data: { ok: true, envPath, env: parsed }, text });
+    return;
+  }
+
+  if (subcmd === 'get') {
+    const key = (positionals[1] ?? '').trim();
+    if (!key) {
+      throw new Error('[env] usage: happys env get KEY');
+    }
+    const value = Object.prototype.hasOwnProperty.call(parsed, key) ? parsed[key] : null;
+    printResult({
+      json,
+      data: { ok: true, envPath, key, value },
+      text: value == null ? '' : String(value),
+    });
+    return;
+  }
+
+  if (subcmd === 'set') {
+    const pairs = positionals.slice(1);
+    if (!pairs.length) {
+      throw new Error('[env] usage: happys env set KEY=VALUE [KEY2=VALUE2...]');
+    }
+    const updates = pairs.map((p) => {
+      const idx = p.indexOf('=');
+      if (idx <= 0) {
+        throw new Error(`[env] set: expected KEY=VALUE, got: ${p}`);
+      }
+      const key = p.slice(0, idx).trim();
+      const value = p.slice(idx + 1);
+      if (!key) {
+        throw new Error(`[env] set: invalid key in: ${p}`);
+      }
+      return { key, value };
+    });
+    await ensureEnvFileUpdated({ envPath, updates });
+    const updatedKeys = updates.map((u) => u.key);
+    printResult({
+      json,
+      data: { ok: true, envPath, updatedKeys },
+      text: `[env] ok: set ${updatedKeys.join(', ')}\n[env] path: ${envPath}`,
+    });
+    return;
+  }
+
+  if (subcmd === 'unset' || subcmd === 'remove' || subcmd === 'rm') {
+    const keys = positionals.slice(1).map((k) => k.trim()).filter(Boolean);
+    if (!keys.length) {
+      throw new Error('[env] usage: happys env unset KEY [KEY2...]');
+    }
+    await ensureEnvFilePruned({ envPath, removeKeys: keys });
+    printResult({
+      json,
+      data: { ok: true, envPath, removedKeys: keys },
+      text: `[env] ok: unset ${keys.join(', ')}\n[env] path: ${envPath}`,
+    });
+    return;
+  }
+
+  throw new Error(`[env] unknown subcommand: ${subcmd}\n[env] usage: happys env set|unset|get|list|path`);
+}
+
+main().catch((err) => {
+  console.error('[env] failed:', err);
+  process.exit(1);
+});
+

package/scripts/env_cmd.test.mjs

@@ -0,0 +1,128 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+function runNode(args, { cwd, env }) {
+  return new Promise((resolve, reject) => {
+    const cleanEnv = {};
+    for (const [k, v] of Object.entries(env ?? {})) {
+      if (v == null) continue;
+      cleanEnv[k] = String(v);
+    }
+    const proc = spawn(process.execPath, args, { cwd, env: cleanEnv, 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) => resolve({ code: code ?? 0, stdout, stderr }));
+  });
+}
+
+test('happys env path defaults to main stack env file when no explicit env file is set', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-env-cmd-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  await mkdir(storageDir, { recursive: true });
+  await mkdir(homeDir, { recursive: true });
+
+  const baseEnv = {
+    ...process.env,
+    // Prevent loading the user's real ~/.happy-stacks/.env via canonical discovery.
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+  };
+
+  const res = await runNode([join(rootDir, 'scripts', 'env.mjs'), 'path', '--json'], {
+    cwd: rootDir,
+    env: baseEnv,
+  });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const out = JSON.parse(res.stdout || '{}');
+  assert.equal(out.ok, true);
+  assert.ok(
+    typeof out.envPath === 'string' && out.envPath.endsWith('/main/env'),
+    `expected main env path to end with /main/env, got: ${out.envPath}`
+  );
+});
+
+test('happys env edits the explicit stack env file when HAPPY_STACKS_ENV_FILE is set', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-env-cmd-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const stackName = 'exp1';
+  const envPath = join(storageDir, stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await mkdir(homeDir, { recursive: true });
+
+  const baseEnv = {
+    ...process.env,
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+    HAPPY_STACKS_ENV_FILE: envPath,
+  };
+
+  const res = await runNode([join(rootDir, 'scripts', 'env.mjs'), 'set', 'FOO=bar'], { cwd: rootDir, env: baseEnv });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const raw = await readFile(envPath, 'utf-8');
+  assert.ok(raw.includes('FOO=bar'), `expected FOO in explicit env file\n${raw}`);
+});
+
+test('happys env (no subcommand) prints usage and exits 0', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-env-cmd-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  await mkdir(storageDir, { recursive: true });
+  await mkdir(homeDir, { recursive: true });
+
+  const baseEnv = {
+    ...process.env,
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+  };
+
+  const res = await runNode([join(rootDir, 'scripts', 'env.mjs')], { cwd: rootDir, env: baseEnv });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  assert.ok(res.stdout.includes('[env] usage:'), `expected usage output\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+});
+
+test('happys env list prints keys in text mode', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-env-cmd-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const stackName = 'exp1';
+  const envPath = join(storageDir, stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await mkdir(homeDir, { recursive: true });
+  await writeFile(envPath, 'FOO=bar\n', 'utf-8');
+
+  const baseEnv = {
+    ...process.env,
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+    HAPPY_STACKS_ENV_FILE: envPath,
+  };
+
+  const res = await runNode([join(rootDir, 'scripts', 'env.mjs'), 'list'], { cwd: rootDir, env: baseEnv });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  assert.ok(res.stdout.includes('FOO=bar'), `expected list output to include FOO=bar\nstdout:\n${res.stdout}`);
+});
+

package/scripts/init.mjs

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { mkdir, writeFile, readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawnSync } from 'node:child_process';
 import { ensureCanonicalHomeEnvUpdated, ensureHomeEnvUpdated } from './utils/env/config.mjs';
@@ -177,12 +177,15 @@ async function main() {
   process.env.HAPPY_LOCAL_HOME_DIR = process.env.HAPPY_LOCAL_HOME_DIR ?? homeDir;
 
   const workspaceDirRaw = parseArgValue(argv, 'workspace-dir');
-  const workspaceDir = expandHome(firstNonEmpty(
+  const workspaceDirExpanded = expandHome(firstNonEmpty(
     workspaceDirRaw,
     process.env.HAPPY_STACKS_WORKSPACE_DIR,
     process.env.HAPPY_LOCAL_WORKSPACE_DIR,
     join(homeDir, 'workspace'),
   ));
+  // If the user passes a relative --workspace-dir, interpret it as relative to the home dir
+  // (not the current cwd). This keeps setup predictable, especially when invoked via `npx`.
+  const workspaceDir = workspaceDirExpanded.startsWith('/') ? workspaceDirExpanded : resolve(homeDir, workspaceDirExpanded);
   process.env.HAPPY_STACKS_WORKSPACE_DIR = workspaceDir;
   process.env.HAPPY_LOCAL_WORKSPACE_DIR = process.env.HAPPY_LOCAL_WORKSPACE_DIR ?? workspaceDir;