@happier-dev/stack 0.1.0-preview.74.1

package/scripts/env.mjs

@@ -0,0 +1,149 @@
+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.HAPPIER_STACK_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:',
+    '  hstack env set KEY=VALUE [KEY2=VALUE2...]',
+    '  hstack env unset KEY [KEY2...]',
+    '  hstack env get KEY',
+    '  hstack env list',
+    '  hstack env path',
+    '',
+    'defaults:',
+    '  - If running under a stack wrapper (HAPPIER_STACK_ENV_FILE is set), edits that stack env file.',
+    '  - Otherwise, edits the main stack env file (~/.happier/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:
+          'hstack 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: 'hstack 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: hstack 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: hstack 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: hstack 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: hstack 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,118 @@
+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 { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runNodeCapture as runNode } from './testkit/stack_script_command_testkit.mjs';
+
+async function withTempRoot(t) {
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-env-cmd-'));
+  t.after(async () => {
+    await rm(tmp, { recursive: true, force: true });
+  });
+  return tmp;
+}
+
+test('hstack env path defaults to main stack env file when no explicit env file is set', async (t) => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await withTempRoot(t);
+
+  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 ~/.happier-stack/.env via canonical discovery.
+    HAPPIER_STACK_HOME_DIR: homeDir,
+    HAPPIER_STACK_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('hstack env edits the explicit stack env file when HAPPIER_STACK_ENV_FILE is set', async (t) => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await withTempRoot(t);
+
+  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,
+    HAPPIER_STACK_HOME_DIR: homeDir,
+    HAPPIER_STACK_STORAGE_DIR: storageDir,
+    HAPPIER_STACK_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('hstack env (no subcommand) prints usage and exits 0', async (t) => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await withTempRoot(t);
+
+  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,
+  };
+
+  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('hstack env list prints keys in text mode', async (t) => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await withTempRoot(t);
+
+  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,
+    HAPPIER_STACK_HOME_DIR: homeDir,
+    HAPPIER_STACK_STORAGE_DIR: storageDir,
+    HAPPIER_STACK_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/exit_cleanup_kills_detached_children_on_crash.integration.test.mjs

@@ -0,0 +1,80 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { runNodeCapture as runNode } from './testkit/stack_script_command_testkit.mjs';
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function waitForPidExit(pid, { timeoutMs = 5_000, intervalMs = 50 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isAlive(pid)) return true;
+    // eslint-disable-next-line no-await-in-loop
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  return !isAlive(pid);
+}
+
+test('installExitCleanup kills detached child process groups on uncaughtException', async (t) => {
+  if (process.platform === 'win32') {
+    t.skip('POSIX-only process-group signaling semantics');
+    return;
+  }
+
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-exit-cleanup-'));
+
+  try {
+    const exitCleanupUrl = pathToFileURL(join(rootDir, 'scripts', 'utils', 'proc', 'exit_cleanup.mjs')).toString();
+    const procUrl = pathToFileURL(join(rootDir, 'scripts', 'utils', 'proc', 'proc.mjs')).toString();
+
+    const parentPath = join(tmp, 'parent.mjs');
+    await writeFile(
+      parentPath,
+      [
+        `import { spawnProc } from ${JSON.stringify(procUrl)};`,
+        `import { installExitCleanup } from ${JSON.stringify(exitCleanupUrl)};`,
+        `const children = [];`,
+        `const child = spawnProc('child', process.execPath, ['-e', 'setInterval(() => {}, 1000)'], process.env);`,
+        `children.push(child);`,
+        `installExitCleanup({ label: 'test', children });`,
+        `console.log(String(child.pid));`,
+        `setTimeout(() => { throw new Error('boom'); }, 50);`,
+        `setInterval(() => {}, 1000);`,
+        '',
+      ].join('\n'),
+      'utf-8'
+    );
+
+    const res = await runNode([parentPath], { cwd: tmp, env: process.env });
+    assert.equal(
+      res.signal,
+      null,
+      `expected process to exit with status, got signal ${res.signal}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`
+    );
+    assert.equal(res.code, 1, `expected exit 1, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+    const pid = Number(res.stdout.trim().split('\n')[0]);
+    assert.ok(Number.isFinite(pid) && pid > 1, `expected pid in stdout, got: ${res.stdout}`);
+
+    const exited = await waitForPidExit(pid, { timeoutMs: 5_000, intervalMs: 50 });
+    assert.ok(exited, `expected detached child pid ${pid} to be stopped`);
+  } finally {
+    try {
+      await rm(tmp, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+  }
+});

package/scripts/happier.mjs

@@ -0,0 +1,82 @@
+import './utils/env/env.mjs';
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseArgs } from './utils/cli/args.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
+import { getComponentDir, getRootDir, getStackName } from './utils/paths/paths.mjs';
+import { resolveCliHomeDir } from './utils/stack/dirs.mjs';
+import { getPublicServerUrlEnvOverride, resolveServerPortFromEnv } from './utils/server/urls.mjs';
+import { applyStackActiveServerScopeEnv } from './utils/auth/stable_scope_id.mjs';
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const { flags } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+
+  if (wantsHelp(argv, { flags })) {
+    printResult({
+      json,
+      data: { passthrough: true },
+      text: [
+        '[happier] usage:',
+        '  hstack happier <happier-cli args...>',
+        '',
+        'notes:',
+        '  - This runs the monorepo CLI component (apps/cli) with stack env defaults.',
+        '  - It auto-fills HAPPIER_HOME_DIR / HAPPIER_SERVER_URL / HAPPIER_WEBAPP_URL when missing.',
+      ].join('\n'),
+    });
+    return;
+  }
+
+  const rootDir = getRootDir(import.meta.url);
+
+  const stackName = (process.env.HAPPIER_STACK_STACK ?? '').toString().trim() || getStackName();
+  const serverPort = resolveServerPortFromEnv({ env: process.env, defaultPort: 3005 });
+
+  const internalServerUrl = `http://127.0.0.1:${serverPort}`;
+  const { publicServerUrl } = getPublicServerUrlEnvOverride({ env: process.env, serverPort, stackName });
+
+  const cliHomeDir = resolveCliHomeDir();
+
+  const cliDir = getComponentDir(rootDir, 'happier-cli');
+  const entrypoint = join(cliDir, 'dist', 'index.mjs');
+  if (!existsSync(entrypoint)) {
+    console.error(`[happier] missing CLI build at: ${entrypoint}`);
+    console.error('Run: hstack bootstrap');
+    process.exit(1);
+  }
+
+  let env = { ...process.env };
+  env.HAPPIER_HOME_DIR = env.HAPPIER_HOME_DIR || cliHomeDir;
+  env.HAPPIER_SERVER_URL = env.HAPPIER_SERVER_URL || internalServerUrl;
+  env.HAPPIER_WEBAPP_URL = env.HAPPIER_WEBAPP_URL || publicServerUrl;
+  env = applyStackActiveServerScopeEnv({
+    env,
+    stackName,
+    cliIdentity: (env.HAPPIER_STACK_CLI_IDENTITY ?? '').toString().trim() || 'default',
+  });
+
+  const res = spawnSync(process.execPath, ['--no-warnings', '--no-deprecation', entrypoint, ...argv], {
+    stdio: 'inherit',
+    env,
+  });
+
+  if (res.error) {
+    const msg = res.error instanceof Error ? res.error.message : String(res.error);
+    console.error(`[happier] failed to run CLI: ${msg}`);
+    process.exit(1);
+  }
+
+  process.exit(res.status ?? 1);
+}
+
+main().catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  console.error('[happier] failed:', message);
+  if (process.env.DEBUG && err instanceof Error && err.stack) {
+    console.error(err.stack);
+  }
+  process.exit(1);
+});