@happier-dev/stack 0.1.0-preview.74.1

package/scripts/self_host_runtime.test.mjs

@@ -0,0 +1,82 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  parseSelfHostInvocation,
+  pickReleaseAsset,
+  renderServerEnvFile,
+  renderServerServiceUnit,
+} from './self_host_runtime.mjs';
+
+test('parseSelfHostInvocation accepts optional self-host prefix', () => {
+  const parsed = parseSelfHostInvocation(['self-host', 'install', '--channel=preview']);
+  assert.equal(parsed.subcommand, 'install');
+  assert.deepEqual(parsed.rest, ['--channel=preview']);
+});
+
+test('parseSelfHostInvocation supports direct command invocation', () => {
+  const parsed = parseSelfHostInvocation(['status', '--json']);
+  assert.equal(parsed.subcommand, 'status');
+  assert.deepEqual(parsed.rest, ['--json']);
+});
+
+test('pickReleaseAsset returns matching archive and checksum assets', () => {
+  const assets = [
+    { name: 'happier-server-v1.2.3-linux-x64.tar.gz', browser_download_url: 'https://example.test/server.tar.gz' },
+    { name: 'checksums-happier-server-v1.2.3.txt', browser_download_url: 'https://example.test/checksums.txt' },
+    { name: 'checksums-happier-server-v1.2.3.txt.minisig', browser_download_url: 'https://example.test/checksums.txt.minisig' },
+  ];
+  const picked = pickReleaseAsset({
+    assets,
+    product: 'happier-server',
+    os: 'linux',
+    arch: 'x64',
+  });
+  assert.equal(picked.archiveUrl, 'https://example.test/server.tar.gz');
+  assert.equal(picked.checksumsUrl, 'https://example.test/checksums.txt');
+  assert.equal(picked.signatureUrl, 'https://example.test/checksums.txt.minisig');
+});
+
+test('pickReleaseAsset rejects releases missing minisign signature assets', () => {
+  assert.throws(() => {
+    pickReleaseAsset({
+      assets: [
+        { name: 'happier-server-v1.2.3-linux-x64.tar.gz', browser_download_url: 'https://example.test/server.tar.gz' },
+        { name: 'checksums-happier-server-v1.2.3.txt', browser_download_url: 'https://example.test/checksums.txt' },
+      ],
+      product: 'happier-server',
+      os: 'linux',
+      arch: 'x64',
+    });
+  }, /signature/i);
+});
+
+test('renderServerServiceUnit references configured binary and env file', () => {
+  const unit = renderServerServiceUnit({
+    serviceName: 'happier-server',
+    binaryPath: '/opt/happier/bin/happier-server',
+    envFilePath: '/etc/happier/server.env',
+    workingDirectory: '/opt/happier',
+    logPath: '/var/log/happier/server.log',
+  });
+  assert.match(unit, /ExecStart=\/opt\/happier\/bin\/happier-server/);
+  assert.match(unit, /EnvironmentFile=\/etc\/happier\/server.env/);
+  assert.match(unit, /WorkingDirectory=\/opt\/happier/);
+  assert.match(unit, /StandardOutput=append:\/var\/log\/happier\/server.log/);
+});
+
+test('renderServerEnvFile emits sqlite/local defaults for self-host mode', () => {
+  const envText = renderServerEnvFile({
+    port: 3005,
+    host: '127.0.0.1',
+    dataDir: '/var/lib/happier',
+    filesDir: '/var/lib/happier/files',
+    dbDir: '/var/lib/happier/pglite',
+  });
+  assert.match(envText, /PORT=3005/);
+  assert.match(envText, /HAPPIER_DB_PROVIDER=sqlite/);
+  assert.match(envText, /HAPPIER_FILES_BACKEND=local/);
+  assert.match(envText, /HAPPIER_SERVER_LIGHT_DATA_DIR=\/var\/lib\/happier/);
+  assert.match(envText, /HAPPIER_SERVER_LIGHT_FILES_DIR=\/var\/lib\/happier\/files/);
+  assert.match(envText, /HAPPIER_SERVER_LIGHT_DB_DIR=\/var\/lib\/happier\/pglite/);
+});

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

@@ -0,0 +1,367 @@
+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 { 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;
+}
+
+function runAsRoot(cmd, args, { cwd, env, timeoutMs = 0, allowFail = false, stdio = 'pipe' } = {}) {
+  const mergedEnv = {
+    ...process.env,
+    ...(env ?? {}),
+  };
+  if (typeof process.getuid === 'function' && process.getuid() === 0) {
+    return run(cmd, args, { 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], {
+    cwd,
+    env: process.env,
+    timeoutMs,
+    allowFail,
+    stdio,
+  });
+}
+
+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 },
+  async (t) => {
+    if (process.platform !== 'linux') {
+      t.skip(`linux-only test (current: ${process.platform})`);
+      return;
+    }
+    if (process.arch !== 'x64') {
+      t.skip(`linux-x64 runner required (current: ${process.arch})`);
+      return;
+    }
+    if (!commandExists('systemctl')) {
+      t.skip('systemctl is required');
+      return;
+    }
+    if (!commandExists('bun')) {
+      t.skip('bun is required to build compiled binaries');
+      return;
+    }
+    if (typeof process.getuid === 'function' && process.getuid() !== 0 && !commandExists('sudo')) {
+      t.skip('sudo/root access is required');
+      return;
+    }
+
+    const repoRoot = resolve(fileURLToPath(new URL('../../..', import.meta.url)));
+    const version = `0.0.0-systemd.${Date.now()}`;
+
+    run(
+      process.execPath,
+      [
+        'scripts/release/build-hstack-binaries.mjs',
+        '--channel=preview',
+        `--version=${version}`,
+        '--targets=linux-x64',
+      ],
+      {
+        cwd: repoRoot,
+        env: { ...process.env },
+        timeoutMs: 8 * 60_000,
+      }
+    );
+    run(
+      process.execPath,
+      [
+        'scripts/release/build-server-binaries.mjs',
+        '--channel=preview',
+        `--version=${version}`,
+        '--targets=linux-x64',
+      ],
+      {
+        cwd: repoRoot,
+        env: { ...process.env },
+        timeoutMs: 8 * 60_000,
+      }
+    );
+
+    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' });
+
+    t.after(async () => {
+      await rm(extractedHstack.extractDir, { recursive: true, force: true });
+      await rm(extractedServer.extractDir, { recursive: true, force: true });
+    });
+
+    const sandboxDir = await mkdtemp(join(tmpdir(), 'happier-self-host-systemd-'));
+    t.after(async () => {
+      await rm(sandboxDir, { recursive: true, force: true });
+    });
+
+    const installRoot = join(sandboxDir, 'opt-happier');
+    const binDir = join(sandboxDir, 'bin');
+    await mkdir(binDir, { recursive: true });
+
+    const hstackPath = join(binDir, 'hstack');
+    await cp(extractedHstack.binaryPath, hstackPath);
+    await chmod(hstackPath, 0o755);
+
+    const serviceName = `happier-server-e2e-${Date.now().toString(36).slice(-6)}`;
+    const serverPort = await reserveLocalhostPort();
+    const commonEnv = {
+      PATH: process.env.PATH ?? '',
+      HAPPIER_SELF_HOST_INSTALL_ROOT: installRoot,
+      HAPPIER_SELF_HOST_BIN_DIR: binDir,
+      HAPPIER_SELF_HOST_SERVICE_NAME: serviceName,
+      HAPPIER_SELF_HOST_SERVER_BINARY: extractedServer.binaryPath,
+      HAPPIER_SELF_HOST_AUTO_UPDATE: '0',
+      HAPPIER_SELF_HOST_HEALTH_TIMEOUT_MS: '240000',
+      HAPPIER_NONINTERACTIVE: '1',
+      HAPPIER_WITH_CLI: '0',
+      HAPPIER_SERVER_PORT: String(serverPort),
+      HAPPIER_SERVER_HOST: '127.0.0.1',
+    };
+    const configDir = String(commonEnv.HAPPIER_SELF_HOST_CONFIG_DIR ?? '/etc/happier');
+    const logDir = String(commonEnv.HAPPIER_SELF_HOST_LOG_DIR ?? '/var/log/happier');
+    const serverEnvPath = join(configDir, 'server.env');
+    const serverLogPath = join(logDir, 'server.log');
+
+    let installSucceeded = false;
+    t.after(() => {
+      if (!installSucceeded) return;
+      runAsRoot(
+        hstackPath,
+        ['self-host', 'uninstall', '--channel=preview', '--yes', '--purge-data', '--json'],
+        {
+          env: commonEnv,
+          allowFail: true,
+          timeoutMs: 120_000,
+          stdio: 'ignore',
+          cwd: '/tmp',
+        }
+      );
+    });
+
+    const installResult = runAsRoot(
+      hstackPath,
+      ['self-host', 'install', '--channel=preview', '--non-interactive', '--without-cli', '--json'],
+      {
+        env: commonEnv,
+        timeoutMs: SELF_HOST_INSTALL_TIMEOUT_MS,
+        allowFail: true,
+        cwd: '/tmp',
+      }
+    );
+    if ((installResult.status ?? 1) !== 0) {
+      const recoveredHealth = await waitForHealth(`http://127.0.0.1:${serverPort}/v1/version`, 120_000);
+      if (!recoveredHealth) {
+        const statusResult = runAsRoot(
+          'systemctl',
+          ['status', `${serviceName}.service`, '--no-pager', '--full'],
+          {
+            env: commonEnv,
+            allowFail: true,
+            timeoutMs: 30_000,
+            cwd: '/tmp',
+          }
+        );
+        const journalResult = runAsRoot(
+          'journalctl',
+          ['-u', `${serviceName}.service`, '-n', '200', '--no-pager'],
+          {
+            env: commonEnv,
+            allowFail: true,
+            timeoutMs: 30_000,
+            cwd: '/tmp',
+          }
+        );
+        const unitResult = runAsRoot(
+          'systemctl',
+          ['cat', `${serviceName}.service`],
+          {
+            env: commonEnv,
+            allowFail: true,
+            timeoutMs: 30_000,
+            cwd: '/tmp',
+          }
+        );
+        const envFileResult = runAsRoot(
+          'cat',
+          [serverEnvPath],
+          {
+            env: commonEnv,
+            allowFail: true,
+            timeoutMs: 30_000,
+            cwd: '/tmp',
+          }
+        );
+        const logDirResult = runAsRoot(
+          'ls',
+          ['-la', logDir],
+          {
+            env: commonEnv,
+            allowFail: true,
+            timeoutMs: 30_000,
+            cwd: '/tmp',
+          }
+        );
+        const serverLogResult = runAsRoot(
+          'tail',
+          ['-n', '300', serverLogPath],
+          {
+            env: commonEnv,
+            allowFail: true,
+            timeoutMs: 30_000,
+            cwd: '/tmp',
+          }
+        );
+        throw new Error(
+          [
+            '[self-host-systemd] self-host install failed and service never became healthy',
+            `install status: ${String(installResult.status ?? 'null')}`,
+            `install stdout:\n${String(installResult.stdout ?? '').trim()}`,
+            `install stderr:\n${String(installResult.stderr ?? '').trim()}`,
+            `systemctl status:\n${String(statusResult.stdout ?? '').trim()}\n${String(statusResult.stderr ?? '').trim()}`,
+            `journalctl tail:\n${String(journalResult.stdout ?? '').trim()}\n${String(journalResult.stderr ?? '').trim()}`,
+            `systemctl cat:\n${String(unitResult.stdout ?? '').trim()}\n${String(unitResult.stderr ?? '').trim()}`,
+            `server env (${serverEnvPath}):\n${String(envFileResult.stdout ?? '').trim()}\n${String(envFileResult.stderr ?? '').trim()}`,
+            `log dir (${logDir}):\n${String(logDirResult.stdout ?? '').trim()}\n${String(logDirResult.stderr ?? '').trim()}`,
+            `server log tail (${serverLogPath}):\n${String(serverLogResult.stdout ?? '').trim()}\n${String(serverLogResult.stderr ?? '').trim()}`,
+          ].join('\n\n')
+        );
+      }
+    }
+    installSucceeded = true;
+
+    const healthOk = await waitForHealth(`http://127.0.0.1:${serverPort}/v1/version`, 90_000);
+    assert.equal(healthOk, true, 'self-host service health endpoint did not become ready');
+
+    const status = runAsRoot(
+      hstackPath,
+      ['self-host', 'status', '--channel=preview', '--json'],
+      {
+        env: commonEnv,
+        timeoutMs: 60_000,
+        cwd: '/tmp',
+      }
+    );
+    const statusPayload = JSON.parse(String(status.stdout ?? '').trim());
+    assert.equal(statusPayload?.ok, true);
+    assert.equal(statusPayload?.service?.name, `${serviceName}.service`);
+    assert.equal(statusPayload?.service?.active, true);
+    assert.equal(statusPayload?.healthy, true);
+
+    runAsRoot('systemctl', ['is-active', '--quiet', `${serviceName}.service`], {
+      env: commonEnv,
+      timeoutMs: 30_000,
+      cwd: '/tmp',
+      stdio: 'ignore',
+    });
+
+    runAsRoot(
+      hstackPath,
+      ['self-host', 'uninstall', '--channel=preview', '--yes', '--purge-data', '--json'],
+      {
+        env: commonEnv,
+        timeoutMs: 120_000,
+        cwd: '/tmp',
+      }
+    );
+    installSucceeded = false;
+
+    const activeAfterUninstall = runAsRoot('systemctl', ['is-active', '--quiet', `${serviceName}.service`], {
+      env: commonEnv,
+      allowFail: true,
+      timeoutMs: 30_000,
+      cwd: '/tmp',
+      stdio: 'ignore',
+    });
+    assert.notEqual(activeAfterUninstall.status, 0, 'service should be inactive after uninstall');
+  }
+);

package/scripts/server_flavor.mjs

@@ -0,0 +1,148 @@
+import './utils/env/env.mjs';
+import { parseArgs } from './utils/cli/args.mjs';
+import { getRootDir } from './utils/paths/paths.mjs';
+import { ensureEnvFileUpdated } from './utils/env/env_file.mjs';
+import { resolveUserConfigEnvPath } from './utils/env/config.mjs';
+import { isTty, promptSelect, withRl } from './utils/cli/wizard.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
+import { bold, cyan, dim, green } from './utils/ui/ansi.mjs';
+
+const FLAVORS = [
+  { label: `happier-server-light (${green('recommended')}) — simplest local install (serves UI)`, value: 'happier-server-light' },
+  { label: `happier-server — full server (Docker-managed infra)`, value: 'happier-server' },
+];
+
+function normalizeFlavor(raw) {
+  const v = (raw ?? '').trim().toLowerCase();
+  if (!v) return '';
+  if (v === 'light' || v === 'server-light' || v === 'happier-server-light' || v === 'happy-server-light') return 'happier-server-light';
+  if (v === 'server' || v === 'full' || v === 'happier-server' || v === 'happy-server') return 'happier-server';
+  return raw.trim();
+}
+
+async function cmdUse({ rootDir, argv }) {
+  const { flags } = parseArgs(argv);
+  const positionals = argv.filter((a) => !a.startsWith('--'));
+  const flavorRaw = positionals[1] ?? '';
+  const flavor = normalizeFlavor(flavorRaw);
+  if (!flavor) {
+    throw new Error('[server-flavor] usage: hstack srv use <happier-server-light|happier-server> [--json]');
+  }
+  if (!['happier-server-light', 'happier-server'].includes(flavor)) {
+    throw new Error(`[server-flavor] unknown flavor: ${flavor}`);
+  }
+
+  const envPath = resolveUserConfigEnvPath({ cliRootDir: rootDir });
+  await ensureEnvFileUpdated({
+    envPath,
+    updates: [
+      { key: 'HAPPIER_STACK_SERVER_COMPONENT', value: flavor },
+    ],
+  });
+
+  const json = wantsJson(argv, { flags });
+  printResult({
+    json,
+    data: { ok: true, flavor },
+    text: `[server-flavor] set HAPPIER_STACK_SERVER_COMPONENT=${flavor} (saved to ${envPath})`,
+  });
+}
+
+async function cmdUseInteractive({ rootDir, argv }) {
+  const { flags } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+
+  await withRl(async (rl) => {
+    const flavor = await promptSelect(rl, {
+      title: `${bold('Server flavor')}\n${dim('Pick the backend you want to run by default. You can change per-stack too.')}`,
+      options: FLAVORS,
+      defaultIndex: 0,
+    });
+    const envPath = resolveUserConfigEnvPath({ cliRootDir: rootDir });
+    await ensureEnvFileUpdated({
+      envPath,
+      updates: [
+        { key: 'HAPPIER_STACK_SERVER_COMPONENT', value: flavor },
+      ],
+    });
+    printResult({
+      json,
+      data: { ok: true, flavor },
+      text: `[server-flavor] set HAPPIER_STACK_SERVER_COMPONENT=${flavor} (saved to ${envPath})`,
+    });
+  });
+}
+
+async function cmdStatus({ argv }) {
+  const { flags } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+  const flavor = process.env.HAPPIER_STACK_SERVER_COMPONENT?.trim() || 'happier-server-light';
+  printResult({ json, data: { flavor }, text: `[server-flavor] current: ${flavor}` });
+}
+
+async function main() {
+  const rootDir = getRootDir(import.meta.url);
+  const argv = process.argv.slice(2);
+  const helpSepIdx = argv.indexOf('--');
+  const helpScopeArgv = helpSepIdx === -1 ? argv : argv.slice(0, helpSepIdx);
+  const { flags } = parseArgs(helpScopeArgv);
+  const positionals = helpScopeArgv.filter((a) => a && a !== '--' && !a.startsWith('-'));
+  const cmd = positionals[0] ?? 'help';
+  const json = wantsJson(helpScopeArgv, { flags });
+
+  const wantsHelpFlag = wantsHelp(helpScopeArgv, { flags });
+  const usageByCmd = new Map([
+    ['status', 'hstack srv status [--json]'],
+    ['use', 'hstack srv use <happier-server-light|happier-server> [--json]'],
+  ]);
+
+  if (wantsHelpFlag && cmd !== 'help') {
+    const usage = usageByCmd.get(cmd);
+    if (usage) {
+      printResult({
+        json,
+        data: { ok: true, cmd, usage },
+        text: [`[server-flavor ${cmd}] usage:`, `  ${usage}`, '', 'see also:', '  hstack srv --help'].join('\n'),
+      });
+      return;
+    }
+  }
+
+  if (wantsHelpFlag || cmd === 'help') {
+    printResult({
+      json,
+      data: { commands: ['status', 'use'] },
+      text: [
+        '[server-flavor] usage:',
+        '  hstack srv status [--json]',
+        '  hstack srv use <happier-server-light|happier-server> [--json]',
+        '  hstack srv use --interactive [--json]',
+        '',
+        'notes:',
+        '  - This sets the default server flavor for future stack runs.',
+      ].join('\n'),
+    });
+    return;
+  }
+
+  if (cmd === 'status') {
+    await cmdStatus({ argv });
+    return;
+  }
+  if (cmd === 'use') {
+    const interactive = argv.includes('--interactive') || argv.includes('-i');
+    if (interactive && isTty()) {
+      await cmdUseInteractive({ rootDir, argv });
+    } else {
+      await cmdUse({ rootDir, argv });
+    }
+    return;
+  }
+
+  throw new Error(`[server-flavor] unknown command: ${cmd}`);
+}
+
+main().catch((err) => {
+  console.error('[server-flavor] failed:', err);
+  process.exit(1);
+});