happy-stacks 0.3.0 → 0.5.0

package/scripts/stack_shorthand_cmd.test.mjs

@@ -0,0 +1,55 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, 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 proc = spawn(process.execPath, args, { cwd, env, 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 <stack> <cmd> ... rewrites to happys stack <cmd> <stack> ... when stack exists', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-shorthand-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const stackName = 'exp-test';
+
+  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_CLI_ROOT_DISABLE: '1',
+  };
+
+  const res = await runNode([join(rootDir, 'bin', 'happys.mjs'), stackName, 'env', '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(`/${stackName}/env`),
+    `expected envPath to end with /${stackName}/env, got: ${out.envPath}`
+  );
+});
+

package/scripts/stack_wt_list.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, 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 }));
+  });
+}
+
+async function touchWorktree(dir) {
+  await mkdir(dir, { recursive: true });
+  // In a git worktree, ".git" is often a file; our detection treats either file or dir as truthy.
+  await writeFile(join(dir, '.git'), 'gitdir: /dev/null\n', 'utf-8');
+}
+
+test('happys stack wt <stack> -- list defaults to active-only (no exhaustive enumeration)', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-stack-wt-list-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const workspaceDir = join(tmp, 'workspace');
+  const componentsDir = join(workspaceDir, 'components');
+  const stackName = 'exp-test';
+
+  // Create isolated worktrees on disk (inside our temp workspace).
+  const wtRoot = join(componentsDir, '.worktrees');
+  const happyActive = join(wtRoot, 'happy', 'slopus', 'pr', 'active-branch');
+  const happyOther = join(wtRoot, 'happy', 'slopus', 'pr', 'other-branch');
+  const cliActive = join(wtRoot, 'happy-cli', 'slopus', 'pr', 'cli-active');
+  const cliOther = join(wtRoot, 'happy-cli', 'slopus', 'pr', 'cli-other');
+  await touchWorktree(happyActive);
+  await touchWorktree(happyOther);
+  await touchWorktree(cliActive);
+  await touchWorktree(cliOther);
+
+  // Stack env selects the active worktrees.
+  const envPath = join(storageDir, stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await writeFile(
+    envPath,
+    [
+      `HAPPY_STACKS_STACK=${stackName}`,
+      `HAPPY_STACKS_COMPONENT_DIR_HAPPY=${happyActive}`,
+      `HAPPY_STACKS_COMPONENT_DIR_HAPPY_CLI=${cliActive}`,
+      '',
+    ].join('\n'),
+    'utf-8'
+  );
+
+  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,
+    HAPPY_STACKS_WORKSPACE_DIR: workspaceDir,
+  };
+
+  const res = await runNode([join(rootDir, 'scripts', 'stack.mjs'), 'wt', stackName, '--', '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(`- active: ${happyActive}`), `expected happy active in output\n${res.stdout}`);
+  assert.ok(res.stdout.includes(`- active: ${cliActive}`), `expected happy-cli active in output\n${res.stdout}`);
+
+  // Should NOT enumerate other worktrees unless --all was passed.
+  assert.ok(!res.stdout.includes(`- ${happyOther}`), `expected happy other to be omitted\n${res.stdout}`);
+  assert.ok(!res.stdout.includes(`- ${cliOther}`), `expected happy-cli other to be omitted\n${res.stdout}`);
+});
+
+test('happys stack wt <stack> -- list --all shows all worktrees (opt-in)', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-stack-wt-list-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const workspaceDir = join(tmp, 'workspace');
+  const componentsDir = join(workspaceDir, 'components');
+  const stackName = 'exp-test';
+
+  const wtRoot = join(componentsDir, '.worktrees');
+  const happyActive = join(wtRoot, 'happy', 'slopus', 'pr', 'active-branch');
+  const happyOther = join(wtRoot, 'happy', 'slopus', 'pr', 'other-branch');
+  await touchWorktree(happyActive);
+  await touchWorktree(happyOther);
+
+  const envPath = join(storageDir, stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await writeFile(
+    envPath,
+    [`HAPPY_STACKS_STACK=${stackName}`, `HAPPY_STACKS_COMPONENT_DIR_HAPPY=${happyActive}`, ''].join('\n'),
+    'utf-8'
+  );
+
+  const baseEnv = {
+    ...process.env,
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+    HAPPY_STACKS_WORKSPACE_DIR: workspaceDir,
+  };
+
+  const res = await runNode([join(rootDir, 'scripts', 'stack.mjs'), 'wt', stackName, '--', 'list', '--all'], {
+    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(`- active: ${happyActive}`), `expected happy active in output\n${res.stdout}`);
+  assert.ok(res.stdout.includes(`- ${happyOther}`), `expected happy other to be listed with --all\n${res.stdout}`);
+});
+

package/scripts/tailscale.mjs

@@ -40,7 +40,9 @@ function extractHttpsUrl(serveStatusText) {
     .find((l) => l.toLowerCase().includes('https://'));
   if (!line) return null;
   const m = line.match(/https:\/\/\S+/i);
-  return m ? m[0] : null;
+  if (!m) return null;
+  // Avoid trailing slash for base URLs (some consumers treat it as a path prefix).
+  return m[0].replace(/\/+$/, '');
 }
 
 function tailscaleStatusMatchesInternalServerUrl(status, internalServerUrl) {
@@ -80,6 +82,16 @@ function extractServeEnableUrl(text) {
   return m ? m[0] : null;
 }
 
+function assertTailscaleAllowed(action) {
+  if (isSandboxed() && !sandboxAllowsGlobalSideEffects()) {
+    throw new Error(
+      `[local] tailscale ${action} is disabled in sandbox mode.\n` +
+        `Reason: Tailscale Serve is global machine state and sandbox runs must be isolated.\n` +
+        `If you really want this, set: HAPPY_STACKS_SANDBOX_ALLOW_GLOBAL=1`
+    );
+  }
+}
+
 function parseTimeoutMs(raw, defaultMs) {
   const s = (raw ?? '').trim();
   if (!s) return defaultMs;
@@ -173,11 +185,13 @@ export async function tailscaleServeHttpsUrl() {
 }
 
 export async function tailscaleServeStatus() {
+  assertTailscaleAllowed('status');
   const cmd = await resolveTailscaleCmd();
   return await runCapture(cmd, ['serve', 'status'], { env: tailscaleEnv(), timeoutMs: tailscaleProbeTimeoutMs() });
 }
 
 export async function tailscaleServeEnable({ internalServerUrl, timeoutMs } = {}) {
+  assertTailscaleAllowed('enable');
   const cmd = await resolveTailscaleCmd();
   const { upstream, servePath } = getServeConfig(internalServerUrl);
   const args = ['serve', '--bg'];
@@ -215,12 +229,16 @@ export async function tailscaleServeEnable({ internalServerUrl, timeoutMs } = {}
 }
 
 export async function tailscaleServeReset({ timeoutMs } = {}) {
+  assertTailscaleAllowed('reset');
   const cmd = await resolveTailscaleCmd();
   const timeout = Number.isFinite(timeoutMs) ? (timeoutMs > 0 ? timeoutMs : 0) : tailscaleUserResetTimeoutMs();
   await run(cmd, ['serve', 'reset'], { env: tailscaleEnv(), timeoutMs: timeout });
 }
 
 export async function maybeEnableTailscaleServe({ internalServerUrl }) {
+  if (isSandboxed() && !sandboxAllowsGlobalSideEffects()) {
+    return null;
+  }
   const enabled = (process.env.HAPPY_LOCAL_TAILSCALE_SERVE ?? '0') === '1';
   if (!enabled) {
     return null;
@@ -234,6 +252,9 @@ export async function maybeEnableTailscaleServe({ internalServerUrl }) {
 }
 
 export async function maybeResetTailscaleServe() {
+  if (isSandboxed() && !sandboxAllowsGlobalSideEffects()) {
+    return;
+  }
   const enabled = (process.env.HAPPY_LOCAL_TAILSCALE_SERVE ?? '0') === '1';
   const resetOnExit = (process.env.HAPPY_LOCAL_TAILSCALE_RESET_ON_EXIT ?? '0') === '1';
   if (!enabled || !resetOnExit) {
@@ -266,6 +287,7 @@ export async function resolvePublicServerUrl({
   defaultPublicUrl,
   envPublicUrl,
   allowEnable = true,
+  stackName = 'main',
 }) {
   const preferTailscalePublicUrl = (process.env.HAPPY_LOCAL_TAILSCALE_PREFER_PUBLIC_URL ?? '1') !== '0';
   const userExplicitlySetPublicUrl =
@@ -275,6 +297,20 @@ export async function resolvePublicServerUrl({
     return { publicServerUrl: envPublicUrl || defaultPublicUrl, source: 'env' };
   }
 
+  // Non-main stacks:
+  // - Never auto-enable (global machine state) by default.
+  // - If the caller explicitly allows it AND Tailscale Serve is already configured for this stack's
+  //   internal URL, prefer the HTTPS URL (safe: status must match the internal URL).
+  if (stackName && stackName !== 'main') {
+    if (allowEnable) {
+      const existing = await tailscaleServeHttpsUrlForInternalServerUrl(internalServerUrl);
+      if (existing) {
+        return { publicServerUrl: existing, source: 'tailscale-status' };
+      }
+    }
+    return { publicServerUrl: envPublicUrl || defaultPublicUrl, source: envPublicUrl ? 'env' : 'default' };
+  }
+
   // If serve is already configured, use its HTTPS URL if present.
   const existing = await tailscaleServeHttpsUrlForInternalServerUrl(internalServerUrl);
   if (existing) {

package/scripts/test.mjs

@@ -1,13 +1,16 @@
 import './utils/env/env.mjs';
 import { parseArgs } from './utils/cli/args.mjs';
 import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
-import { getComponentDir, getRootDir } from './utils/paths/paths.mjs';
+import { componentDirEnvKey, getComponentDir, getRootDir } from './utils/paths/paths.mjs';
 import { ensureDepsInstalled } from './utils/proc/pm.mjs';
 import { pathExists } from './utils/fs/fs.mjs';
 import { run } from './utils/proc/proc.mjs';
 import { detectPackageManagerCmd, pickFirstScript, readPackageJsonScripts } from './utils/proc/package_scripts.mjs';
+import { getInvokedCwd, inferComponentFromCwd } from './utils/cli/cwd_scope.mjs';
 
 const DEFAULT_COMPONENTS = ['happy', 'happy-cli', 'happy-server-light', 'happy-server'];
+const EXTRA_COMPONENTS = ['stacks'];
+const VALID_COMPONENTS = [...DEFAULT_COMPONENTS, ...EXTRA_COMPONENTS];
 
 function pickTestScript(scripts) {
   const candidates = [
@@ -28,33 +31,67 @@ async function main() {
   if (wantsHelp(argv, { flags })) {
     printResult({
       json,
-      data: { components: DEFAULT_COMPONENTS, flags: ['--json'] },
+      data: { components: VALID_COMPONENTS, flags: ['--json'] },
       text: [
         '[test] usage:',
         '  happys test [component...] [--json]',
         '',
         'components:',
-        `  ${DEFAULT_COMPONENTS.join(' | ')}`,
+        `  ${VALID_COMPONENTS.join(' | ')}`,
         '',
         'examples:',
         '  happys test',
+        '  happys test stacks',
         '  happys test happy happy-cli',
+        '',
+        'note:',
+        '  If run from inside a component checkout/worktree and no components are provided, defaults to that component.',
       ].join('\n'),
     });
     return;
   }
 
+  const rootDir = getRootDir(import.meta.url);
+
   const positionals = argv.filter((a) => !a.startsWith('--'));
-  const requested = positionals.length ? positionals : ['all'];
+  const inferred =
+    positionals.length === 0
+      ? inferComponentFromCwd({
+          rootDir,
+          invokedCwd: getInvokedCwd(process.env),
+          components: DEFAULT_COMPONENTS,
+        })
+      : null;
+  if (inferred) {
+    const stacksKey = componentDirEnvKey(inferred.component);
+    const legacyKey = stacksKey.replace(/^HAPPY_STACKS_/, 'HAPPY_LOCAL_');
+    if (!(process.env[stacksKey] ?? '').toString().trim() && !(process.env[legacyKey] ?? '').toString().trim()) {
+      process.env[stacksKey] = inferred.repoDir;
+    }
+  }
+
+  const requested = positionals.length ? positionals : inferred ? [inferred.component] : ['all'];
   const wantAll = requested.includes('all');
+  // Default `all` excludes "stacks" to avoid coupling to component repos and their test baselines.
   const components = wantAll ? DEFAULT_COMPONENTS : requested;
 
-  const rootDir = getRootDir(import.meta.url);
-
   const results = [];
   for (const component of components) {
-    if (!DEFAULT_COMPONENTS.includes(component)) {
-      results.push({ component, ok: false, skipped: false, error: `unknown component (expected one of: ${DEFAULT_COMPONENTS.join(', ')})` });
+    if (!VALID_COMPONENTS.includes(component)) {
+      results.push({ component, ok: false, skipped: false, error: `unknown component (expected one of: ${VALID_COMPONENTS.join(', ')})` });
+      continue;
+    }
+
+    if (component === 'stacks') {
+      try {
+        // eslint-disable-next-line no-console
+        console.log('[test] stacks: running node --test (happy-stacks unit tests)');
+        // Restrict to explicit *.test.mjs files to avoid accidentally executing scripts/test.mjs.
+        await run('sh', ['-lc', 'node --test "scripts/**/*.test.mjs"'], { cwd: rootDir, env: process.env });
+        results.push({ component, ok: true, skipped: false, dir: rootDir, pm: 'node', script: '--test' });
+      } catch (e) {
+        results.push({ component, ok: false, skipped: false, dir: rootDir, pm: 'node', script: '--test', error: String(e?.message ?? e) });
+      }
       continue;
     }