@happier-dev/stack 0.1.0-preview.100.1 → 0.1.0-preview.138.1

package/scripts/self_host_service_e2e_harness.mjs

@@ -0,0 +1,93 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdtemp, readdir } from 'node:fs/promises';
+import { createServer } from 'node:net';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const SELF_HOST_PORT_MIN = 20_000;
+const SELF_HOST_PORT_MAX = 29_999;
+const SELF_HOST_PORT_ATTEMPTS = 40;
+
+export function commandExists(cmd) {
+  const name = String(cmd ?? '').trim();
+  if (!name) return false;
+  if (process.platform === 'win32') {
+    return spawnSync('where', [name], { stdio: 'ignore' }).status === 0;
+  }
+  return spawnSync('sh', ['-lc', `command -v ${name} >/dev/null 2>&1`], { stdio: 'ignore' }).status === 0;
+}
+
+export function run(cmd, args, { label, cwd, env, timeoutMs = 0, allowFail = false, stdio = 'pipe' } = {}) {
+  const prefix = label ? `[${label}] ` : '';
+  const result = spawnSync(cmd, args, {
+    cwd,
+    env: env ?? process.env,
+    encoding: 'utf-8',
+    stdio,
+    timeout: timeoutMs || undefined,
+  });
+  const timedOut = result.error && result.error.code === 'ETIMEDOUT';
+  if (!allowFail && (timedOut || (result.status ?? 1) !== 0)) {
+    const stderr = String(result.stderr ?? '').trim();
+    const stdout = String(result.stdout ?? '').trim();
+    const reason = timedOut ? 'timed out' : `exited with status ${result.status}`;
+    throw new Error(`${prefix}${cmd} ${args.join(' ')} ${reason}\nstdout:\n${stdout}\nstderr:\n${stderr}`);
+  }
+  return result;
+}
+
+export async function extractBinaryFromArtifact({ artifactPath, binaryName, label } = {}) {
+  const path = String(artifactPath ?? '').trim();
+  const name = String(binaryName ?? '').trim();
+  assert.ok(path, 'artifactPath is required');
+  assert.ok(name, 'binaryName is required');
+  const extractDir = await mkdtemp(join(tmpdir(), 'happier-self-host-artifact-'));
+  run('tar', ['-xzf', path, '-C', extractDir], { label, timeoutMs: 60_000 });
+  const roots = await readdir(extractDir);
+  assert.ok(roots.length > 0, `expected extracted root directory for ${path}`);
+  return {
+    extractDir,
+    binaryPath: join(extractDir, roots[0], name),
+  };
+}
+
+export async function waitForHealth(url, timeoutMs = 60_000) {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    try {
+      const response = await fetch(String(url), {
+        headers: { accept: 'application/json' },
+      });
+      if (response.ok) {
+        const payload = await response.json().catch(() => ({}));
+        if (payload?.ok === true) return true;
+      }
+    } catch {
+      // keep polling until timeout
+    }
+    await new Promise((resolveSleep) => setTimeout(resolveSleep, 1500));
+  }
+  return false;
+}
+
+async function canBindLocalhostPort(port) {
+  return await new Promise((resolvePort) => {
+    const server = createServer();
+    server.unref();
+    server.once('error', () => resolvePort(false));
+    server.listen(port, '127.0.0.1', () => {
+      server.close((error) => resolvePort(!error));
+    });
+  });
+}
+
+export async function reserveLocalhostPort() {
+  for (let attempt = 0; attempt < SELF_HOST_PORT_ATTEMPTS; attempt += 1) {
+    const candidate =
+      SELF_HOST_PORT_MIN + Math.floor(Math.random() * (SELF_HOST_PORT_MAX - SELF_HOST_PORT_MIN + 1));
+    if (await canBindLocalhostPort(candidate)) return candidate;
+  }
+  throw new Error('failed to reserve localhost port from non-ephemeral range');
+}
+

package/scripts/self_host_systemd.real.integration.test.mjs

@@ -1,38 +1,13 @@
 import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { chmod, cp, mkdir, mkdtemp, readdir, rm } from 'node:fs/promises';
-import { createServer } from 'node:net';
+import { chmod, cp, mkdir, mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import test from 'node:test';
 import { fileURLToPath } from 'node:url';
 
-const SELF_HOST_PORT_MIN = 20_000;
-const SELF_HOST_PORT_MAX = 29_999;
-const SELF_HOST_PORT_ATTEMPTS = 40;
 const SELF_HOST_INSTALL_TIMEOUT_MS = 420_000;
 
-function commandExists(cmd) {
-  return spawnSync('bash', ['-lc', `command -v ${cmd} >/dev/null 2>&1`], { stdio: 'ignore' }).status === 0;
-}
-
-function run(cmd, args, { cwd, env, timeoutMs = 0, allowFail = false, stdio = 'pipe' } = {}) {
-  const result = spawnSync(cmd, args, {
-    cwd,
-    env: env ?? process.env,
-    encoding: 'utf-8',
-    stdio,
-    timeout: timeoutMs || undefined,
-  });
-  const timedOut = result.error && result.error.code === 'ETIMEDOUT';
-  if (!allowFail && (timedOut || (result.status ?? 1) !== 0)) {
-    const stderr = String(result.stderr ?? '').trim();
-    const stdout = String(result.stdout ?? '').trim();
-    const reason = timedOut ? 'timed out' : `exited with status ${result.status}`;
-    throw new Error(`[self-host-systemd] ${cmd} ${args.join(' ')} ${reason}\nstdout:\n${stdout}\nstderr:\n${stderr}`);
-  }
-  return result;
-}
+import { commandExists, extractBinaryFromArtifact, reserveLocalhostPort, run, waitForHealth } from './self_host_service_e2e_harness.mjs';
 
 function runAsRoot(cmd, args, { cwd, env, timeoutMs = 0, allowFail = false, stdio = 'pipe' } = {}) {
   const mergedEnv = {
@@ -40,13 +15,14 @@ function runAsRoot(cmd, args, { cwd, env, timeoutMs = 0, allowFail = false, stdi
     ...(env ?? {}),
   };
   if (typeof process.getuid === 'function' && process.getuid() === 0) {
-    return run(cmd, args, { cwd, env: mergedEnv, timeoutMs, allowFail, stdio });
+    return run(cmd, args, { label: 'self-host-systemd', cwd, env: mergedEnv, timeoutMs, allowFail, stdio });
   }
   if (!commandExists('sudo')) {
     throw new Error('[self-host-systemd] sudo is required for systemd self-host test');
   }
   const envArgs = Object.entries(mergedEnv).map(([key, value]) => `${key}=${String(value ?? '')}`);
   return run('sudo', ['-E', 'env', ...envArgs, cmd, ...args], {
+    label: 'self-host-systemd',
     cwd,
     env: process.env,
     timeoutMs,
@@ -55,62 +31,6 @@ function runAsRoot(cmd, args, { cwd, env, timeoutMs = 0, allowFail = false, stdi
   });
 }
 
-async function extractBinaryFromArtifact({ artifactPath, binaryName }) {
-  const extractDir = await mkdtemp(join(tmpdir(), 'happier-self-host-systemd-artifact-'));
-  run('tar', ['-xzf', artifactPath, '-C', extractDir], { timeoutMs: 30_000 });
-  const roots = await readdir(extractDir);
-  assert.ok(roots.length > 0, `expected extracted root directory for ${artifactPath}`);
-  return {
-    extractDir,
-    binaryPath: join(extractDir, roots[0], binaryName),
-  };
-}
-
-async function waitForHealth(url, timeoutMs = 60_000) {
-  const started = Date.now();
-  while (Date.now() - started < timeoutMs) {
-    try {
-      const response = await fetch(url, {
-        headers: { accept: 'application/json' },
-      });
-      if (response.ok) {
-        const payload = await response.json().catch(() => ({}));
-        if (payload?.ok === true) {
-          return true;
-        }
-      }
-    } catch {
-      // keep polling until timeout
-    }
-    await new Promise((resolve) => setTimeout(resolve, 1500));
-  }
-  return false;
-}
-
-async function canBindLocalhostPort(port) {
-  return await new Promise((resolvePort) => {
-    const server = createServer();
-    server.unref();
-    server.once('error', () => resolvePort(false));
-    server.listen(port, '127.0.0.1', () => {
-      server.close((error) => {
-        resolvePort(!error);
-      });
-    });
-  });
-}
-
-async function reserveLocalhostPort() {
-  for (let attempt = 0; attempt < SELF_HOST_PORT_ATTEMPTS; attempt += 1) {
-    const candidate =
-      SELF_HOST_PORT_MIN + Math.floor(Math.random() * (SELF_HOST_PORT_MAX - SELF_HOST_PORT_MIN + 1));
-    if (await canBindLocalhostPort(candidate)) {
-      return candidate;
-    }
-  }
-  throw new Error('failed to reserve localhost port from non-ephemeral range');
-}
-
 test(
   'compiled hstack self-host install/uninstall works on systemd host without repo checkout',
   { timeout: 15 * 60_000 },
@@ -148,6 +68,7 @@ test(
         '--targets=linux-x64',
       ],
       {
+        label: 'self-host-systemd',
         cwd: repoRoot,
         env: { ...process.env },
         timeoutMs: 8 * 60_000,
@@ -162,6 +83,7 @@ test(
         '--targets=linux-x64',
       ],
       {
+        label: 'self-host-systemd',
         cwd: repoRoot,
         env: { ...process.env },
         timeoutMs: 8 * 60_000,
@@ -171,8 +93,8 @@ test(
     const hstackArtifact = join(repoRoot, 'dist', 'release-assets', 'stack', `hstack-v${version}-linux-x64.tar.gz`);
     const serverArtifact = join(repoRoot, 'dist', 'release-assets', 'server', `happier-server-v${version}-linux-x64.tar.gz`);
 
-    const extractedHstack = await extractBinaryFromArtifact({ artifactPath: hstackArtifact, binaryName: 'hstack' });
-    const extractedServer = await extractBinaryFromArtifact({ artifactPath: serverArtifact, binaryName: 'happier-server' });
+    const extractedHstack = await extractBinaryFromArtifact({ label: 'self-host-systemd', artifactPath: hstackArtifact, binaryName: 'hstack' });
+    const extractedServer = await extractBinaryFromArtifact({ label: 'self-host-systemd', artifactPath: serverArtifact, binaryName: 'happier-server' });
 
     t.after(async () => {
       await rm(extractedHstack.extractDir, { recursive: true, force: true });

package/scripts/service.mjs

@@ -3,9 +3,11 @@ import { run, runCapture } from './utils/proc/proc.mjs';
 import { getComponentDir, getDefaultAutostartPaths, getRootDir, getSystemdUnitInfo, resolveStackEnvPath } from './utils/paths/paths.mjs';
 import { getInternalServerUrl, getPublicServerUrlEnvOverride } from './utils/server/urls.mjs';
 import { ensureMacAutostartDisabled, ensureMacAutostartEnabled } from './utils/service/autostart_darwin.mjs';
+import { installService as installManagedService, uninstallService as uninstallManagedService } from './utils/service/service_manager.mjs';
 import { getCanonicalHomeDir } from './utils/env/config.mjs';
 import { isSandboxed, sandboxAllowsGlobalSideEffects } from './utils/env/sandbox.mjs';
 import { expandHome } from './utils/paths/canonical_home.mjs';
+import { resolveInstalledCliRoot, resolveInstalledPath } from './utils/paths/runtime.mjs';
 import { spawn } from 'node:child_process';
 import { homedir } from 'node:os';
 import { existsSync } from 'node:fs';
@@ -109,6 +111,33 @@ function ensureLinuxSystemModeSupported({ mode }) {
   }
 }
 
+async function resolveStackAutostartProgramArgs({ rootDir, mode, systemUser }) {
+  const base = getCanonicalHomeDir();
+  const candidates =
+    process.platform === 'win32'
+      ? [join(base, 'bin', 'hstack.exe'), join(base, 'bin', 'hstack.cmd'), join(base, 'bin', 'hstack')]
+      : [join(base, 'bin', 'hstack')];
+
+  let shimPath = candidates.find((p) => existsSync(p)) ?? '';
+  if (mode === 'system' && systemUser) {
+    const home = await resolveHomeDirForUser(systemUser);
+    if (home) {
+      const systemCandidates =
+        process.platform === 'win32'
+          ? [
+              join(home, '.happier-stack', 'bin', 'hstack.exe'),
+              join(home, '.happier-stack', 'bin', 'hstack.cmd'),
+              join(home, '.happier-stack', 'bin', 'hstack'),
+            ]
+          : [join(home, '.happier-stack', 'bin', 'hstack')];
+      shimPath = systemCandidates.find((p) => existsSync(p)) ?? shimPath;
+    }
+  }
+
+  if (shimPath) return [shimPath, 'start'];
+  return [process.execPath, resolveInstalledPath(rootDir, 'bin/hstack.mjs'), 'start'];
+}
+
 export async function installService({ mode = 'user', systemUser = null } = {}) {
   if (isSandboxed() && !sandboxAllowsGlobalSideEffects()) {
     throw new Error(
@@ -118,11 +147,8 @@ export async function installService({ mode = 'user', systemUser = null } = {})
     );
   }
   ensureLinuxSystemModeSupported({ mode });
-  if (process.platform !== 'darwin' && process.platform !== 'linux') {
-    throw new Error('[local] service install is only supported on macOS (launchd) and Linux (systemd).');
-  }
   const rootDir = getRootDir(import.meta.url);
-  const { label } = getDefaultAutostartPaths();
+  const { label, stdoutPath, stderrPath, baseDir } = getDefaultAutostartPaths();
   const env = getAutostartEnv({ rootDir, mode });
   // Ensure the env file exists so the service never points at a missing path.
   try {
@@ -137,17 +163,43 @@ export async function installService({ mode = 'user', systemUser = null } = {})
   } catch {
     // ignore
   }
+  const programArgs = await resolveStackAutostartProgramArgs({ rootDir, mode, systemUser });
+  const workingDirectory =
+    process.platform === 'linux'
+      ? '%h'
+      : process.platform === 'darwin'
+        ? resolveInstalledCliRoot(rootDir)
+        : baseDir;
+
+  await installManagedService({
+    platform: process.platform,
+    mode,
+    homeDir: homedir(),
+    spec: {
+      label,
+      description: `Happier Stack (${label})`,
+      programArgs,
+      workingDirectory,
+      env,
+      runAsUser: mode === 'system' && systemUser ? systemUser : '',
+      stdoutPath,
+      stderrPath,
+    },
+    persistent: true,
+  });
+
+  if (process.platform === 'win32') {
+    console.log(`${green('✓')} service installed ${dim('(Windows scheduled task)')}`);
+    return;
+  }
   if (process.platform === 'darwin') {
-    await ensureMacAutostartEnabled({ rootDir, label, env });
     console.log(`${green('✓')} service installed ${dim('(macOS launchd)')}`);
     return;
   }
   if (mode === 'system') {
-    await ensureSystemdSystemServiceEnabled({ rootDir, label, env, systemUser });
     console.log(`${green('✓')} service installed ${dim('(Linux systemd system)')}`);
     return;
   }
-  await ensureSystemdUserServiceEnabled({ rootDir, label, env });
   console.log(`${green('✓')} service installed ${dim('(Linux systemd --user)')}`);
 }
 
@@ -157,25 +209,40 @@ export async function uninstallService({ mode = 'user' } = {}) {
     return;
   }
   ensureLinuxSystemModeSupported({ mode });
-  if (process.platform !== 'darwin' && process.platform !== 'linux') return;
+  const rootDir = getRootDir(import.meta.url);
+  const { label, stdoutPath, stderrPath, baseDir } = getDefaultAutostartPaths();
+  const env = getAutostartEnv({ rootDir, mode });
+  const programArgs = await resolveStackAutostartProgramArgs({ rootDir, mode, systemUser: null });
+  const workingDirectory =
+    process.platform === 'linux'
+      ? '%h'
+      : process.platform === 'darwin'
+        ? resolveInstalledCliRoot(rootDir)
+        : baseDir;
+
+  await uninstallManagedService({
+    platform: process.platform,
+    mode,
+    homeDir: homedir(),
+    spec: {
+      label,
+      description: `Happier Stack (${label})`,
+      programArgs,
+      workingDirectory,
+      env,
+      stdoutPath,
+      stderrPath,
+    },
+    persistent: true,
+  });
 
-  if (process.platform === 'linux') {
-    if (mode === 'system') {
-      await ensureSystemdSystemServiceDisabled({ remove: true });
-      console.log(`${green('✓')} service uninstalled ${dim('(systemd system unit removed)')}`);
-      return;
-    }
-    await ensureSystemdUserServiceDisabled({ remove: true });
-    console.log(`${green('✓')} service uninstalled ${dim('(systemd user unit removed)')}`);
+  if (process.platform === 'win32') {
+    console.log(`${green('✓')} service uninstalled ${dim('(Windows task removed)')}`);
     return;
   }
-  const { plistPath, label } = getDefaultAutostartPaths();
-
-  await ensureMacAutostartDisabled({ label });
-  try {
-    await rm(plistPath, { force: true });
-  } catch {
-    // ignore
+  if (process.platform === 'linux') {
+    console.log(`${green('✓')} service uninstalled ${dim('(systemd unit removed)')}`);
+    return;
   }
   console.log(`${green('✓')} service uninstalled ${dim('(plist removed)')}`);
 }
@@ -633,8 +700,8 @@ async function main() {
   const systemUser = resolveSystemUser(helpScopeArgv);
   ensureLinuxSystemModeSupported({ mode });
 
-  if (process.platform !== 'darwin' && process.platform !== 'linux') {
-    throw new Error('[local] service commands are only supported on macOS (launchd) and Linux (systemd).');
+  if (process.platform !== 'darwin' && process.platform !== 'linux' && process.platform !== 'win32') {
+    throw new Error('[local] service commands are only supported on macOS (launchd), Linux (systemd), and Windows (schtasks).');
   }
   const positionals = helpScopeArgv.filter((a) => a && a !== '--' && !a.startsWith('-'));
   const cmd = positionals[0] ?? 'help';
@@ -711,7 +778,17 @@ async function main() {
           health = { ok: false, status: null, body: null };
         }
 
-        if (process.platform === 'darwin') {
+        if (process.platform === 'win32') {
+          const { label, stdoutPath, stderrPath } = getDefaultAutostartPaths();
+          const taskName = `Happier\\${label}`;
+          let schtasksStatus = null;
+          try {
+            schtasksStatus = await runCapture('schtasks', ['/Query', '/TN', taskName, '/FO', 'LIST', '/V']);
+          } catch (e) {
+            schtasksStatus = e && typeof e === 'object' && 'out' in e ? e.out : null;
+          }
+          printResult({ json, data: { label, taskName, stdoutPath, stderrPath, internalUrl, schtasksStatus, health } });
+        } else if (process.platform === 'darwin') {
           const { plistPath, stdoutPath, stderrPath, label } = getDefaultAutostartPaths();
           let launchctlLine = null;
           try {
@@ -736,6 +813,11 @@ async function main() {
           printResult({ json, data: { mode, unitName, unitPath, internalUrl, systemctlStatus, health } });
         }
       } else {
+        if (process.platform === 'win32') {
+          const { label } = getDefaultAutostartPaths();
+          await run('schtasks', ['/Query', '/TN', `Happier\\${label}`]);
+          return;
+        }
         if (process.platform === 'darwin') {
           await showStatus();
         } else {
@@ -749,6 +831,13 @@ async function main() {
       }
       return;
     case 'start':
+      if (process.platform === 'win32') {
+        const { label } = getDefaultAutostartPaths();
+        await run('schtasks', ['/Run', '/TN', `Happier\\${label}`]).catch(() => {});
+        await postStartDiagnostics();
+        if (json) printResult({ json, data: { ok: true, action: 'start' } });
+        return;
+      }
       if (process.platform === 'darwin') {
         await startLaunchAgent({ persistent: false });
       } else {
@@ -763,6 +852,12 @@ async function main() {
       if (json) printResult({ json, data: { ok: true, action: 'start' } });
       return;
     case 'stop':
+      if (process.platform === 'win32') {
+        const { label } = getDefaultAutostartPaths();
+        await run('schtasks', ['/End', '/TN', `Happier\\${label}`]).catch(() => {});
+        if (json) printResult({ json, data: { ok: true, action: 'stop' } });
+        return;
+      }
       if (process.platform === 'darwin') {
         await stopLaunchAgent({ persistent: false });
       } else {
@@ -776,6 +871,14 @@ async function main() {
       if (json) printResult({ json, data: { ok: true, action: 'stop' } });
       return;
     case 'restart':
+      if (process.platform === 'win32') {
+        const { label } = getDefaultAutostartPaths();
+        await run('schtasks', ['/End', '/TN', `Happier\\${label}`]).catch(() => {});
+        await run('schtasks', ['/Run', '/TN', `Happier\\${label}`]).catch(() => {});
+        await postStartDiagnostics();
+        if (json) printResult({ json, data: { ok: true, action: 'restart' } });
+        return;
+      }
       if (process.platform === 'darwin') {
         if (!(await restartLaunchAgentBestEffort())) {
           await stopLaunchAgent({ persistent: false });
@@ -794,6 +897,14 @@ async function main() {
       if (json) printResult({ json, data: { ok: true, action: 'restart' } });
       return;
     case 'enable':
+      if (process.platform === 'win32') {
+        const { label } = getDefaultAutostartPaths();
+        await run('schtasks', ['/Change', '/TN', `Happier\\${label}`, '/Enable']).catch(() => {});
+        await run('schtasks', ['/Run', '/TN', `Happier\\${label}`]).catch(() => {});
+        await postStartDiagnostics();
+        if (json) printResult({ json, data: { ok: true, action: 'enable' } });
+        return;
+      }
       if (process.platform === 'darwin') {
         await startLaunchAgent({ persistent: true });
       } else {
@@ -808,6 +919,13 @@ async function main() {
       if (json) printResult({ json, data: { ok: true, action: 'enable' } });
       return;
     case 'disable':
+      if (process.platform === 'win32') {
+        const { label } = getDefaultAutostartPaths();
+        await run('schtasks', ['/End', '/TN', `Happier\\${label}`]).catch(() => {});
+        await run('schtasks', ['/Change', '/TN', `Happier\\${label}`, '/Disable']).catch(() => {});
+        if (json) printResult({ json, data: { ok: true, action: 'disable' } });
+        return;
+      }
       if (process.platform === 'darwin') {
         await stopLaunchAgent({ persistent: true });
       } else {
@@ -821,6 +939,15 @@ async function main() {
       if (json) printResult({ json, data: { ok: true, action: 'disable' } });
       return;
     case 'logs':
+      if (process.platform === 'win32') {
+        const { stdoutPath, stderrPath } = getDefaultAutostartPaths();
+        const out = await readLastLines(stdoutPath, 200).catch(() => '');
+        const err = await readLastLines(stderrPath, 200).catch(() => '');
+        console.log(bullets([kv('stdout:', stdoutPath), kv('stderr:', stderrPath)]));
+        if (out.trim()) console.log(out.trimEnd());
+        if (err.trim()) console.log(err.trimEnd());
+        return;
+      }
       if (process.platform === 'darwin') {
         await showLogs();
       } else {
@@ -834,6 +961,9 @@ async function main() {
       }
       return;
     case 'tail':
+      if (process.platform === 'win32') {
+        throw new Error('[local] service tail is not supported on Windows yet. Use: hstack service logs');
+      }
       if (process.platform === 'darwin') {
         await tailLogs();
       } else {

package/scripts/stack/command_arguments.mjs

@@ -13,6 +13,7 @@ const STACK_NAME_FIRST_SUPPORTED_COMMANDS = new Set([
   'create-dev-auth-seed',
   'daemon',
   'happier',
+  'bug-report',
   'env',
   'auth',
   'dev',

package/scripts/stack/help_text.mjs

@@ -10,6 +10,7 @@ const STACK_HELP_USAGE_LINES = [
   'hstack stack create-dev-auth-seed [name] [--server=happier-server|happier-server-light] [--login|--no-login] [--skip-default-seed] [--non-interactive] [--json]',
   'hstack stack daemon <name> start|stop|restart|status [--json]',
   'hstack stack happier <name> [-- ...]',
+  'hstack stack bug-report <name> [-- ...]',
   'hstack stack env <name> set KEY=VALUE [KEY2=VALUE2...] | unset KEY [KEY2...] | get KEY | list | path [--json]',
   'hstack stack auth <name> status|login|copy-from [--json]',
   'hstack stack dev <name> [-- ...]',
@@ -48,6 +49,7 @@ export const STACK_HELP_COMMANDS = [
   'daemon',
   'eas',
   'happier',
+  'bug-report',
   'env',
   'auth',
   'dev',

package/scripts/stack_daemon_cmd.integration.test.mjs

@@ -448,6 +448,43 @@ test('hstack stack daemon <name> start uses runtime server port when env port is
   );
 });
 
+test('hstack stack daemon <name> start uses explicit HAPPIER_SERVER_URL when env port and runtime port are missing', async (t) => {
+  const fixture = await createDaemonFixture(t, {
+    prefix: 'happy-stacks-stack-daemon-explicit-server-url-',
+    stackName: 'exp-test',
+    serverPort: 4101,
+  });
+
+  await writeDummyAuth({ cliHomeDir: fixture.stackCliHome });
+
+  const explicitPort = fixture.serverPort + 9;
+  const envPath = join(fixture.storageDir, fixture.stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await writeFile(
+    envPath,
+    [
+      `HAPPIER_STACK_REPO_DIR=${fixture.baseEnv.HAPPIER_STACK_WORKSPACE_DIR}/happier`,
+      `HAPPIER_STACK_CLI_HOME_DIR=${fixture.stackCliHome}`,
+      `HAPPIER_SERVER_URL=http://127.0.0.1:${explicitPort}`,
+      `HAPPIER_WEBAPP_URL=http://happier-exp-test.localhost:${explicitPort}`,
+      '',
+    ].join('\n'),
+    'utf-8'
+  );
+
+  registerDaemonCleanup(t, { env: fixture.baseEnv, stackName: fixture.stackName });
+
+  const startRes = await runHstack(['stack', 'daemon', fixture.stackName, 'start', '--json'], { env: fixture.baseEnv });
+  assertExitOk(startRes, 'stack daemon start uses explicit HAPPIER_SERVER_URL');
+
+  const logPath = join(fixture.stackCliHome, 'stub-daemon.log');
+  const logText = await readLogText(logPath);
+  assert.ok(
+    logText.includes(`server_url=http://127.0.0.1:${explicitPort}`),
+    `expected daemon env to target explicit HAPPIER_SERVER_URL port ${explicitPort}\n${logText}`
+  );
+});
+
 test('hstack stack auth <name> login --identity=<name> --print prints identity-scoped HAPPIER_HOME_DIR', async (t) => {
   const fixture = await createDaemonFixture(t, {
     prefix: 'happier-stack-auth-identity-',

package/scripts/stack_happy_cmd.integration.test.mjs

@@ -25,6 +25,7 @@ async function writeStubHappyCli({ cliDir, message }) {
     [
       `console.log(JSON.stringify({`,
       `  message: ${JSON.stringify(message)},`,
+      `  args: process.argv.slice(2),`,
       `  stack: process.env.HAPPIER_STACK_STACK || null,`,
       `  envFile: process.env.HAPPIER_STACK_ENV_FILE || null,`,
       `  homeDir: process.env.HAPPIER_HOME_DIR || null,`,
@@ -261,3 +262,38 @@ test('hstack stack <name> happier ... stack-name-first shorthand works', async (
   assert.equal(out.message, 'name-first');
   assert.equal(out.stack, fixture.stackName);
 });
+
+test('hstack stack bug-report <name> forwards bug-report command under stack env', async (t) => {
+  const fixture = await createHappyStackFixture(t, {
+    prefix: 'happier-stack-stack-bug-report-',
+    message: 'bug-report-alias',
+    serverPort: 4099,
+  });
+
+  const res = await runNodeCapture(
+    [
+      join(rootDir, 'bin', 'hstack.mjs'),
+      'stack',
+      'bug-report',
+      fixture.stackName,
+      '--',
+      '--title',
+      'CLI bug',
+      '--summary',
+      'summary',
+      '--current-behavior',
+      'current',
+      '--expected-behavior',
+      'expected',
+      '--accept-privacy-notice',
+      '--no-include-diagnostics',
+    ],
+    { cwd: rootDir, env: fixture.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.trim());
+  assert.equal(out.message, 'bug-report-alias');
+  assert.equal(out.stack, fixture.stackName);
+  assert.equal(out.args[0], 'bug-report');
+});