@happier-dev/stack 0.1.0-preview.5.1

package/scripts/stack_interactive_monorepo_group.test.mjs

@@ -0,0 +1,128 @@
+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 { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { interactiveNew } from './utils/stack/interactive_stack_config.mjs';
+
+function mkRl() {
+  return { question: async () => '' };
+}
+
+function createInteractiveDeps({ prompted = [], selectedRepo = 'tmp/mono-wt' } = {}) {
+  return {
+    prompt: async (_rl, _question, { defaultValue } = {}) => defaultValue ?? '',
+    promptSelect: async (_rl, { options, defaultIndex = 0 } = {}) => options?.[defaultIndex]?.value,
+    promptWorktreeSource: async ({ component }) => {
+      prompted.push(component);
+      if (selectedRepo != null) return selectedRepo;
+      throw new Error(`unexpected promptWorktreeSource call: ${component}`);
+    },
+  };
+}
+
+test('interactive stack new in monorepo mode prompts once for shared repo source', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happier-stack-interactive-new-mono-'));
+  const prompted = [];
+
+  const prevWorkspace = process.env.HAPPIER_STACK_WORKSPACE_DIR;
+  const prevOwner = process.env.HAPPIER_STACK_OWNER;
+  try {
+    const workspaceDir = join(tmp, 'workspace');
+    process.env.HAPPIER_STACK_WORKSPACE_DIR = workspaceDir;
+    process.env.HAPPIER_STACK_OWNER = 'test';
+
+    const monoRoot = join(workspaceDir, 'tmp', 'test', 'mono-wt');
+    await mkdir(join(monoRoot, 'apps', 'ui'), { recursive: true });
+    await mkdir(join(monoRoot, 'apps', 'cli'), { recursive: true });
+    await mkdir(join(monoRoot, 'apps', 'server'), { recursive: true });
+    await writeFile(join(monoRoot, '.git'), 'gitdir: dummy\n', 'utf-8');
+    await writeFile(join(monoRoot, 'apps', 'ui', 'package.json'), '{}\n', 'utf-8');
+    await writeFile(join(monoRoot, 'apps', 'cli', 'package.json'), '{}\n', 'utf-8');
+    await writeFile(join(monoRoot, 'apps', 'server', 'package.json'), '{}\n', 'utf-8');
+
+    const out = await interactiveNew({
+      rootDir,
+      rl: mkRl(),
+      defaults: {
+        stackName: 'exp-mono-int',
+        port: 1,
+        serverComponent: 'happier-server-light',
+        createRemote: 'upstream',
+        repo: null,
+      },
+      deps: createInteractiveDeps({ prompted }),
+    });
+
+    assert.deepEqual(prompted, ['happier-ui']);
+    assert.equal(out.repo, 'tmp/mono-wt');
+  } finally {
+    if (prevWorkspace == null) {
+      delete process.env.HAPPIER_STACK_WORKSPACE_DIR;
+    } else {
+      process.env.HAPPIER_STACK_WORKSPACE_DIR = prevWorkspace;
+    }
+    if (prevOwner == null) {
+      delete process.env.HAPPIER_STACK_OWNER;
+    } else {
+      process.env.HAPPIER_STACK_OWNER = prevOwner;
+    }
+    await rm(tmp, { recursive: true, force: true });
+  }
+});
+
+test('interactive stack new skips worktree prompt when repo is already provided', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happier-stack-interactive-new-mono-preseed-'));
+  const prompted = [];
+
+  const prevWorkspace = process.env.HAPPIER_STACK_WORKSPACE_DIR;
+  const prevOwner = process.env.HAPPIER_STACK_OWNER;
+  try {
+    const workspaceDir = join(tmp, 'workspace');
+    process.env.HAPPIER_STACK_WORKSPACE_DIR = workspaceDir;
+    process.env.HAPPIER_STACK_OWNER = 'test';
+
+    const monoRoot = join(workspaceDir, 'tmp', 'test', 'mono-wt');
+    await mkdir(join(monoRoot, 'apps', 'ui'), { recursive: true });
+    await mkdir(join(monoRoot, 'apps', 'cli'), { recursive: true });
+    await mkdir(join(monoRoot, 'apps', 'server'), { recursive: true });
+    await writeFile(join(monoRoot, '.git'), 'gitdir: dummy\n', 'utf-8');
+    await writeFile(join(monoRoot, 'apps', 'ui', 'package.json'), '{}\n', 'utf-8');
+    await writeFile(join(monoRoot, 'apps', 'cli', 'package.json'), '{}\n', 'utf-8');
+    await writeFile(join(monoRoot, 'apps', 'server', 'package.json'), '{}\n', 'utf-8');
+
+    const out = await interactiveNew({
+      rootDir,
+      rl: mkRl(),
+      defaults: {
+        stackName: 'exp-mono-preseed',
+        port: 1,
+        serverComponent: 'happier-server-light',
+        createRemote: 'upstream',
+        repo: 'dev',
+      },
+      deps: createInteractiveDeps({ prompted, selectedRepo: null }),
+    });
+
+    assert.deepEqual(prompted, []);
+    assert.equal(out.repo, 'dev');
+  } finally {
+    if (prevWorkspace == null) {
+      delete process.env.HAPPIER_STACK_WORKSPACE_DIR;
+    } else {
+      process.env.HAPPIER_STACK_WORKSPACE_DIR = prevWorkspace;
+    }
+    if (prevOwner == null) {
+      delete process.env.HAPPIER_STACK_OWNER;
+    } else {
+      process.env.HAPPIER_STACK_OWNER = prevOwner;
+    }
+    await rm(tmp, { recursive: true, force: true });
+  }
+});

package/scripts/stack_monorepo_defaults.test.mjs

@@ -0,0 +1,31 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { setupStackNewMonorepoFixture } from './testkit/stack_new_monorepo_testkit.mjs';
+
+test('hstack stack new defaults repo token variants to workspace main monorepo checkout', async (t) => {
+  const fixture = await setupStackNewMonorepoFixture({
+    importMetaUrl: import.meta.url,
+    t,
+    tmpPrefix: 'happy-stacks-stack-monorepo-defaults-',
+  });
+  const mainMonorepoRoot = await fixture.createMonorepoCheckout('main');
+
+  const cases = [
+    { name: 'implicit default repo', stackName: 'exp-test', args: [] },
+    { name: '--repo=main token', stackName: 'exp-main-token', args: ['--repo=main', '--no-copy-auth'] },
+    { name: '--repo=default token', stackName: 'exp-default-token', args: ['--repo=default', '--no-copy-auth'] },
+  ];
+
+  for (const testCase of cases) {
+    const res = await fixture.runStackNew([testCase.stackName, ...testCase.args, '--json']);
+    assert.equal(
+      res.code,
+      0,
+      `${testCase.name}: expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`
+    );
+
+    const contents = await fixture.readStackEnv(testCase.stackName);
+    assert.ok(contents.includes(`HAPPIER_STACK_REPO_DIR=${mainMonorepoRoot}\n`), `${testCase.name}\n${contents}`);
+    assert.ok(!contents.includes('HAPPIER_STACK_COMPONENT_DIR_'), `${testCase.name}\n${contents}`);
+  }
+});

package/scripts/stack_monorepo_repo_dev_token.test.mjs

@@ -0,0 +1,32 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { setupStackNewMonorepoFixture } from './testkit/stack_new_monorepo_testkit.mjs';
+
+test('hstack stack new repo selectors pin workspace dev monorepo checkout', async (t) => {
+  const fixture = await setupStackNewMonorepoFixture({
+    importMetaUrl: import.meta.url,
+    t,
+    tmpPrefix: 'hstack-stack-dev-token-',
+  });
+
+  await fixture.createMonorepoCheckout('main');
+  const devRoot = await fixture.createMonorepoCheckout('dev');
+
+  const cases = [
+    { name: '--repo=dev token', stackName: 'exp-dev-token', repoArg: '--repo=dev' },
+    { name: '--repo=<abs dev path>', stackName: 'exp-dev-abs', repoArg: `--repo=${devRoot}` },
+  ];
+
+  for (const testCase of cases) {
+    const res = await fixture.runStackNew([testCase.stackName, testCase.repoArg, '--no-copy-auth', '--json']);
+    assert.equal(
+      res.code,
+      0,
+      `${testCase.name}: expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`
+    );
+
+    const contents = await fixture.readStackEnv(testCase.stackName);
+    assert.ok(contents.includes(`HAPPIER_STACK_REPO_DIR=${devRoot}\n`), `${testCase.name}\n${contents}`);
+    assert.ok(!contents.includes('HAPPIER_STACK_COMPONENT_DIR_'), `${testCase.name}\n${contents}`);
+  }
+});

package/scripts/stack_monorepo_server_light_from_happy_spec.test.mjs

@@ -0,0 +1,37 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { setupStackNewMonorepoFixture } from './testkit/stack_new_monorepo_testkit.mjs';
+
+test('hstack stack new pins HAPPIER_STACK_REPO_DIR from monorepo path specs', async (t) => {
+  const fixture = await setupStackNewMonorepoFixture({
+    importMetaUrl: import.meta.url,
+    t,
+    tmpPrefix: 'happier-stack-monorepo-spec-',
+  });
+
+  const monoRoot = await fixture.createMonorepoCheckout('tmp/leeroy/leeroy-wip', { includeServerPrisma: true });
+
+  const cases = [
+    { name: 'absolute monorepo path', stackName: 'exp-mono-spec', repoArg: `--repo=${monoRoot}` },
+    { name: 'workspace-relative monorepo path', stackName: 'exp-mono-relative', repoArg: '--repo=./tmp/leeroy/leeroy-wip' },
+  ];
+
+  for (const testCase of cases) {
+    const res = await fixture.runStackNew([
+      testCase.stackName,
+      testCase.repoArg,
+      '--server=happier-server-light',
+      '--no-copy-auth',
+      '--json',
+    ]);
+    assert.equal(
+      res.code,
+      0,
+      `${testCase.name}: expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`
+    );
+
+    const contents = await fixture.readStackEnv(testCase.stackName);
+    assert.ok(contents.includes(`HAPPIER_STACK_REPO_DIR=${monoRoot}\n`), `${testCase.name}\n${contents}`);
+    assert.ok(!contents.includes('HAPPIER_STACK_COMPONENT_DIR_'), `${testCase.name}\n${contents}`);
+  }
+});

package/scripts/stack_new_name_normalize_cmd.test.mjs

@@ -0,0 +1,38 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { setupStackNewMonorepoFixture } from './testkit/stack_new_monorepo_testkit.mjs';
+
+test('hstack stack new normalizes stack names across valid and punctuation-heavy inputs', async (t) => {
+  const fixture = await setupStackNewMonorepoFixture({
+    importMetaUrl: import.meta.url,
+    t,
+    tmpPrefix: 'happier-stack-new-name-',
+  });
+  await fixture.createMonorepoCheckout('main', { includeServerPrisma: true });
+
+  const cases = [
+    { rawName: 'My Stack', normalized: 'my-stack' },
+    { rawName: 'already-valid', normalized: 'already-valid' },
+    { rawName: '  MIXED__Case...Name  ', normalized: 'mixed-case-name' },
+    { rawName: 'alpha---beta', normalized: 'alpha-beta' },
+  ];
+
+  for (const testCase of cases) {
+    const res = await fixture.runStackNew([testCase.rawName, '--json']);
+    assert.equal(
+      res.code,
+      0,
+      `${testCase.rawName}: expected exit 0, got ${res.code} (signal: ${res.signal})\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`
+    );
+
+    const parsed = JSON.parse(res.stdout.trim());
+    assert.equal(parsed?.stackName, testCase.normalized, `${testCase.rawName}: unexpected stackName`);
+    assert.ok(
+      typeof parsed?.envPath === 'string' && parsed.envPath.includes(`/${testCase.normalized}/env`),
+      `${testCase.rawName}: unexpected envPath ${parsed?.envPath}`
+    );
+
+    const contents = await fixture.readStackEnv(testCase.normalized);
+    assert.ok(contents.includes(`HAPPIER_STACK_STACK=${testCase.normalized}\n`), `${testCase.rawName}\n${contents}`);
+  }
+});

package/scripts/stack_pr_name_normalize_cmd.test.mjs

@@ -0,0 +1,84 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, rm, 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', (data) => (stdout += String(data)));
+    proc.stderr.on('data', (data) => (stderr += String(data)));
+    proc.on('error', reject);
+    proc.on('exit', (code, signal) => resolve({ code: code ?? (signal ? 128 : 0), signal, stdout, stderr }));
+  });
+}
+
+test('hstack stack pr rejects stack names that normalize to reserved main', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happier-stack-pr-main-'));
+
+  try {
+    const workspaceDir = join(tmp, 'workspace');
+    const storageDir = join(tmp, 'storage');
+    const homeDir = join(tmp, 'home');
+    const sandboxDir = join(tmp, 'sandbox');
+
+    const env = {
+      ...process.env,
+      HAPPIER_STACK_HOME_DIR: homeDir,
+      HAPPIER_STACK_WORKSPACE_DIR: workspaceDir,
+      HAPPIER_STACK_STORAGE_DIR: storageDir,
+      HAPPIER_STACK_SANDBOX_DIR: sandboxDir,
+    };
+
+    const res = await runNode([join(rootDir, 'scripts', 'stack.mjs'), 'pr', 'Main'], { cwd: rootDir, env });
+    assert.notEqual(res.code, 0, `expected non-zero exit\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+    assert.match(
+      `${res.stderr}\n${res.stdout}`,
+      /stack name "main" is reserved/i,
+      `expected reserved-name error\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`
+    );
+  } finally {
+    await rm(tmp, { recursive: true, force: true });
+  }
+});
+
+test('hstack stack pr rejects names that normalize to an existing stack', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happier-stack-pr-collision-'));
+
+  try {
+    const workspaceDir = join(tmp, 'workspace');
+    const storageDir = join(tmp, 'storage');
+    const homeDir = join(tmp, 'home');
+    const sandboxDir = join(tmp, 'sandbox');
+
+    await mkdir(join(storageDir, 'dev-auth'), { recursive: true });
+    await writeFile(join(storageDir, 'dev-auth', 'env'), 'HAPPIER_STACK_STACK=dev-auth\n', 'utf8');
+
+    const env = {
+      ...process.env,
+      HAPPIER_STACK_HOME_DIR: homeDir,
+      HAPPIER_STACK_WORKSPACE_DIR: workspaceDir,
+      HAPPIER_STACK_STORAGE_DIR: storageDir,
+      HAPPIER_STACK_SANDBOX_DIR: sandboxDir,
+    };
+
+    const res = await runNode([join(rootDir, 'scripts', 'stack.mjs'), 'pr', 'Dev-Auth'], { cwd: rootDir, env });
+    assert.notEqual(res.code, 0, `expected non-zero exit\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+    assert.match(
+      `${res.stderr}\n${res.stdout}`,
+      /stack already exists/i,
+      `expected collision error\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`
+    );
+  } finally {
+    await rm(tmp, { recursive: true, force: true });
+  }
+});

package/scripts/stack_resume_cmd.integration.test.mjs

@@ -0,0 +1,134 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync } from 'node:fs';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { runNodeCapture } from './testkit/stack_script_command_testkit.mjs';
+
+const scriptsDir = dirname(fileURLToPath(import.meta.url));
+const rootDir = dirname(scriptsDir);
+
+async function ensureMinimalHappierMonorepo({ monoRoot }) {
+  await mkdir(join(monoRoot, 'apps', 'ui'), { recursive: true });
+  await mkdir(join(monoRoot, 'apps', 'cli', 'bin'), { recursive: true });
+  await mkdir(join(monoRoot, 'apps', 'cli', 'dist'), { recursive: true });
+  await mkdir(join(monoRoot, 'apps', 'server'), { recursive: true });
+  await writeFile(join(monoRoot, 'apps', 'ui', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'cli', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'server', 'package.json'), '{}\n', 'utf-8');
+}
+
+async function writeStubHappyCli({ cliDir }) {
+  const script = [
+    "import { appendFileSync } from 'node:fs';",
+    "import { join } from 'node:path';",
+    '',
+    'const args = process.argv.slice(2);',
+    "const home = process.env.HAPPIER_HOME_DIR || process.cwd();",
+    "const logPath = join(home, 'resume-invocations.log');",
+    "const supportsDaemonResume = process.env.STUB_DAEMON_RESUME_SUPPORT === '1';",
+    '',
+    'if (args[0] === \'daemon\' && args[1] === \'--help\') {',
+    '  if (supportsDaemonResume) {',
+    "    console.log('Usage:\\n  happier daemon resume <sessionId...>');",
+    '  } else {',
+    "    console.log('happier daemon - Daemon management');",
+    "    console.log('Usage: happier daemon start|stop|status|list');",
+    '  }',
+    '  process.exit(0);',
+    '}',
+    '',
+    'if (args[0] === \'daemon\' && args[1] === \'resume\') {',
+    "  appendFileSync(logPath, `daemon resume ${args.slice(2).join(' ')}\\n`, 'utf-8');",
+    '  process.exit(0);',
+    '}',
+    '',
+    "appendFileSync(logPath, `unexpected ${args.join(' ')}\\n`, 'utf-8');",
+    'process.exit(0);',
+    '',
+  ].join('\n');
+
+  await writeFile(join(cliDir, 'dist', 'index.mjs'), script, 'utf-8');
+  await writeFile(join(cliDir, 'bin', 'happier.mjs'), "import '../dist/index.mjs';\n", 'utf-8');
+}
+
+async function createResumeFixture(t, { stackName = 'exp-test', serverPort = 4101 } = {}) {
+  const tmp = await mkdtemp(join(tmpdir(), 'happier-stack-resume-'));
+  t.after(async () => {
+    await rm(tmp, { recursive: true, force: true });
+  });
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const workspaceDir = join(tmp, 'workspace');
+  const monoRoot = join(workspaceDir, 'happier');
+  const cliDir = join(monoRoot, 'apps', 'cli');
+  const stackCliHome = join(storageDir, stackName, 'cli');
+
+  await ensureMinimalHappierMonorepo({ monoRoot });
+  await writeStubHappyCli({ cliDir });
+  await mkdir(stackCliHome, { recursive: true });
+
+  const envPath = join(storageDir, stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await writeFile(
+    envPath,
+    [
+      `HAPPIER_STACK_REPO_DIR=${monoRoot}`,
+      `HAPPIER_STACK_CLI_HOME_DIR=${stackCliHome}`,
+      `HAPPIER_STACK_SERVER_PORT=${serverPort}`,
+      '',
+    ].join('\n'),
+    'utf-8'
+  );
+
+  return {
+    stackName,
+    stackCliHome,
+    baseEnv: {
+      ...process.env,
+      HAPPIER_STACK_HOME_DIR: homeDir,
+      HAPPIER_STACK_STORAGE_DIR: storageDir,
+      HAPPIER_STACK_WORKSPACE_DIR: workspaceDir,
+      HAPPIER_STACK_CLI_ROOT_DISABLE: '1',
+    },
+  };
+}
+
+test('hstack stack resume fails closed when happier daemon does not support resume', async (t) => {
+  const fixture = await createResumeFixture(t);
+  const res = await runNodeCapture(
+    [join(rootDir, 'bin', 'hstack.mjs'), 'stack', 'resume', fixture.stackName, 'session-1', '--json'],
+    { cwd: rootDir, env: fixture.baseEnv }
+  );
+
+  assert.equal(
+    res.code,
+    1,
+    `expected exit 1 when daemon resume is unsupported\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`
+  );
+  assert.match(res.stdout, /resume_not_supported/i);
+
+  const invocationLog = join(fixture.stackCliHome, 'resume-invocations.log');
+  assert.equal(existsSync(invocationLog), false, 'expected daemon resume not to be invoked');
+});
+
+test('hstack stack resume invokes happier daemon resume when supported', async (t) => {
+  const fixture = await createResumeFixture(t);
+  const res = await runNodeCapture(
+    [join(rootDir, 'bin', 'hstack.mjs'), 'stack', 'resume', fixture.stackName, 'session-a', 'session-b', '--json'],
+    {
+      cwd: rootDir,
+      env: {
+        ...fixture.baseEnv,
+        STUB_DAEMON_RESUME_SUPPORT: '1',
+      },
+    }
+  );
+
+  assert.equal(res.code, 0, `expected exit 0\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  assert.match(res.stdout, /"resumed":\s*\[\s*"session-a",\s*"session-b"\s*\]/);
+});

package/scripts/stack_server_flavors_defaults.test.mjs

@@ -0,0 +1,64 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { join } from 'node:path';
+
+import { setupStackNewMonorepoFixture } from './testkit/stack_new_monorepo_testkit.mjs';
+
+test('hstack stack new server flavor defaults and explicit full flavor pin coherent env values', async (t) => {
+  const fixture = await setupStackNewMonorepoFixture({
+    importMetaUrl: import.meta.url,
+    t,
+    tmpPrefix: 'happier-stack-server-flavors-',
+  });
+  const monoRoot = await fixture.createMonorepoCheckout('main', { includeServerPrisma: true });
+
+  const cases = [
+    {
+      name: 'default server flavor',
+      stackName: 'exp-flavors-light-default',
+      args: ['--json'],
+      assertEnv(contents) {
+        assert.ok(contents.includes('HAPPIER_STACK_SERVER_COMPONENT=happier-server-light\n'), contents);
+        assert.ok(contents.includes('HAPPIER_DB_PROVIDER=sqlite\n'), contents);
+        assert.ok(
+          contents.includes(`HAPPIER_SERVER_LIGHT_DATA_DIR=${join(fixture.storageDir, 'exp-flavors-light-default', 'server-light')}\n`),
+          contents
+        );
+        assert.ok(
+          contents.includes(`HAPPIER_SERVER_LIGHT_FILES_DIR=${join(fixture.storageDir, 'exp-flavors-light-default', 'server-light', 'files')}\n`),
+          contents
+        );
+        assert.equal(
+          contents.includes(`HAPPIER_SERVER_LIGHT_DB_DIR=${join(fixture.storageDir, 'exp-flavors-light-default', 'server-light', 'pglite')}\n`),
+          false,
+          contents
+        );
+      },
+    },
+    {
+      name: 'explicit full server flavor',
+      stackName: 'exp-flavors-full-explicit',
+      args: ['--server=happier-server', '--no-copy-auth', '--json'],
+      assertEnv(contents) {
+        assert.ok(contents.includes('HAPPIER_STACK_SERVER_COMPONENT=happier-server\n'), contents);
+        assert.ok(contents.includes('HAPPIER_DB_PROVIDER=postgres\n'), contents);
+        assert.ok(contents.includes('HAPPIER_STACK_MANAGED_INFRA=1\n'), contents);
+        assert.ok(!contents.includes('HAPPIER_SERVER_LIGHT_DATA_DIR='), contents);
+      },
+    },
+  ];
+
+  for (const testCase of cases) {
+    const res = await fixture.runStackNew([testCase.stackName, ...testCase.args]);
+    assert.equal(
+      res.code,
+      0,
+      `${testCase.name}: expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`
+    );
+
+    const contents = await fixture.readStackEnv(testCase.stackName);
+    assert.ok(contents.includes(`HAPPIER_STACK_REPO_DIR=${monoRoot}\n`), `${testCase.name}\n${contents}`);
+    assert.ok(!contents.includes('HAPPIER_STACK_COMPONENT_DIR_'), `${testCase.name}\n${contents}`);
+    testCase.assertEnv(contents);
+  }
+});

package/scripts/stack_shorthand_cmd.integration.test.mjs

@@ -0,0 +1,74 @@
+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 { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runNodeCapture } from './testkit/stack_script_command_testkit.mjs';
+
+test('hstack <stack> <cmd> ... rewrites to hstack stack <cmd> <stack> ... when stack exists', async (t) => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-shorthand-'));
+  t.after(async () => {
+    await rm(tmp, { recursive: true, force: true }).catch(() => {});
+  });
+
+  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,
+    HAPPIER_STACK_HOME_DIR: homeDir,
+    HAPPIER_STACK_STORAGE_DIR: storageDir,
+    HAPPIER_STACK_CLI_ROOT_DISABLE: '1',
+  };
+
+  const res = await runNodeCapture([join(rootDir, 'bin', 'hstack.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}`
+  );
+});
+
+test('hstack does not rewrite shorthand when stack does not exist', async (t) => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-shorthand-missing-'));
+  t.after(async () => {
+    await rm(tmp, { recursive: true, force: true }).catch(() => {});
+  });
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+
+  await mkdir(storageDir, { recursive: true });
+  await mkdir(homeDir, { recursive: true });
+
+  const baseEnv = {
+    ...process.env,
+    HAPPIER_STACK_HOME_DIR: homeDir,
+    HAPPIER_STACK_STORAGE_DIR: storageDir,
+    HAPPIER_STACK_CLI_ROOT_DISABLE: '1',
+  };
+
+  const res = await runNodeCapture([join(rootDir, 'bin', 'hstack.mjs'), 'missing-stack', 'env', 'path', '--json'], {
+    cwd: rootDir,
+    env: baseEnv,
+  });
+  assert.equal(res.code, 1, `expected exit 1, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  assert.match(res.stderr, /^\[hstack\] unknown command: missing-stack/m, res.stderr);
+});

package/scripts/stack_stop_sweeps_legacy_infra_without_kind.integration.test.mjs

@@ -0,0 +1,44 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { isAlive, setupStackStopSweepFixture, spawnOwnedSleep, waitForProcessAlive, waitForProcessExit } from './testkit/stack_stop_sweeps_testkit.mjs';
+
+test('hstack stack stop sweeps legacy infra without HAPPIER_STACK_PROCESS_KIND=infra', async (t) => {
+  const fixture = await setupStackStopSweepFixture({
+    importMetaUrl: import.meta.url,
+    t,
+    tmpPrefix: 'hstack-stack-stop-sweep-legacy-',
+  });
+  const legacyInfra = fixture.trackChild(spawnOwnedSleep({
+    env: {
+      ...process.env,
+      HAPPIER_STACK_STACK: fixture.stackName,
+      HAPPIER_STACK_ENV_FILE: fixture.envPath,
+      // Simulate a yarn/npm-managed infra process from older stacks (no kind tag).
+      npm_lifecycle_event: 'dev:light',
+      npm_package_name: '@happier-dev/server',
+    },
+  }));
+  assert.ok(Number(legacyInfra.pid) > 1, 'expected legacy infra pid');
+  await waitForProcessAlive({ pid: legacyInfra.pid, timeoutMs: 2_000, intervalMs: 25, label: 'legacy infra process (pre-stop)' });
+  assert.ok(isAlive(legacyInfra.pid), 'expected legacy infra child to be alive');
+
+  const sessionLike = fixture.trackChild(spawnOwnedSleep({
+    env: {
+      ...process.env,
+      HAPPIER_STACK_STACK: fixture.stackName,
+      HAPPIER_STACK_ENV_FILE: fixture.envPath,
+      // Deliberately no npm_lifecycle_event and no process kind tag.
+    },
+  }));
+  assert.ok(Number(sessionLike.pid) > 1, 'expected session-like child pid');
+  await waitForProcessAlive({ pid: sessionLike.pid, timeoutMs: 2_000, intervalMs: 25, label: 'session-like process (pre-stop)' });
+  assert.ok(isAlive(sessionLike.pid), 'expected session-like child to be alive');
+
+  const res = await fixture.runStackStop(['--json']);
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  assert.equal(res.signal, null, `expected process to exit normally, got signal ${res.signal}`);
+
+  await waitForProcessExit({ pid: legacyInfra.pid, timeoutMs: 10_000, intervalMs: 50, label: 'legacy infra process' });
+  assert.ok(!isAlive(legacyInfra.pid), `expected legacy infra pid ${legacyInfra.pid} to be stopped`);
+  assert.ok(isAlive(sessionLike.pid), `expected session-like pid ${sessionLike.pid} to still be alive`);
+});