@happier-dev/stack 0.1.0-preview.17.1 → 0.1.0-preview.21.1

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

@@ -0,0 +1,217 @@
+import assert from 'node:assert/strict';
+import { 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_INSTALL_TIMEOUT_MS = 420_000;
+
+import { commandExists, extractBinaryFromArtifact, reserveLocalhostPort, run, waitForHealth } from './self_host_service_e2e_harness.mjs';
+
+function currentTarget() {
+  if (process.platform !== 'win32') return '';
+  if (process.arch === 'x64') return 'windows-x64';
+  return '';
+}
+
+function readTail(path) {
+  const escaped = String(path ?? '').replaceAll("'", "''");
+  return run(
+    'powershell',
+    ['-NoProfile', '-Command', `Get-Content -LiteralPath '${escaped}' -Tail 200 -ErrorAction SilentlyContinue`],
+    { label: 'self-host-schtasks', allowFail: true, timeoutMs: 20_000 }
+  );
+}
+
+test(
+  'compiled hstack self-host install/uninstall works on Windows schtasks host without repo checkout',
+  { timeout: 15 * 60_000 },
+  async (t) => {
+    if (process.platform !== 'win32') {
+      t.skip(`windows-only test (current: ${process.platform})`);
+      return;
+    }
+    const target = currentTarget();
+    if (!target) {
+      t.skip(`unsupported Windows runner architecture: ${process.arch}`);
+      return;
+    }
+    if (!commandExists('schtasks')) {
+      t.skip('schtasks is required');
+      return;
+    }
+    if (!commandExists('powershell')) {
+      t.skip('powershell is required');
+      return;
+    }
+    if (!commandExists('bun')) {
+      t.skip('bun is required to build compiled binaries');
+      return;
+    }
+
+    const repoRoot = resolve(fileURLToPath(new URL('../../..', import.meta.url)));
+    const version = `0.0.0-schtasks.${Date.now()}`;
+
+    run(
+      process.execPath,
+      [
+        'scripts/release/build-hstack-binaries.mjs',
+        '--channel=preview',
+        `--version=${version}`,
+        `--targets=${target}`,
+      ],
+      {
+        label: 'self-host-schtasks',
+        cwd: repoRoot,
+        env: { ...process.env },
+        timeoutMs: 10 * 60_000,
+      }
+    );
+    run(
+      process.execPath,
+      [
+        'scripts/release/build-server-binaries.mjs',
+        '--channel=preview',
+        `--version=${version}`,
+        `--targets=${target}`,
+      ],
+      {
+        label: 'self-host-schtasks',
+        cwd: repoRoot,
+        env: { ...process.env },
+        timeoutMs: 10 * 60_000,
+      }
+    );
+
+    const hstackArtifact = join(repoRoot, 'dist', 'release-assets', 'stack', `hstack-v${version}-${target}.tar.gz`);
+    const serverArtifact = join(repoRoot, 'dist', 'release-assets', 'server', `happier-server-v${version}-${target}.tar.gz`);
+
+    const extractedHstack = await extractBinaryFromArtifact({ label: 'self-host-schtasks', artifactPath: hstackArtifact, binaryName: 'hstack.exe' });
+    const extractedServer = await extractBinaryFromArtifact({ label: 'self-host-schtasks', artifactPath: serverArtifact, binaryName: 'happier-server.exe' });
+
+    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-schtasks-'));
+    t.after(async () => {
+      await rm(sandboxDir, { recursive: true, force: true });
+    });
+
+    const installRoot = join(sandboxDir, 'self-host');
+    const binDir = join(sandboxDir, 'bin');
+    const configDir = join(sandboxDir, 'config');
+    const dataDir = join(sandboxDir, 'data');
+    const logDir = join(sandboxDir, 'logs');
+    await mkdir(binDir, { recursive: true });
+
+    const hstackPath = join(binDir, 'hstack.exe');
+    await cp(extractedHstack.binaryPath, hstackPath);
+
+    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_CONFIG_DIR: configDir,
+      HAPPIER_SELF_HOST_DATA_DIR: dataDir,
+      HAPPIER_SELF_HOST_LOG_DIR: logDir,
+      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 serverOutLog = join(logDir, 'server.out.log');
+    const serverErrLog = join(logDir, 'server.err.log');
+
+    const taskName = `Happier\\${serviceName}`;
+
+    let installSucceeded = false;
+    t.after(() => {
+      if (!installSucceeded) return;
+      run(
+        hstackPath,
+        ['self-host', 'uninstall', '--channel=preview', '--mode=user', '--yes', '--purge-data', '--json'],
+        {
+          env: commonEnv,
+          allowFail: true,
+          timeoutMs: 180_000,
+          stdio: 'ignore',
+          cwd: sandboxDir,
+        }
+      );
+    });
+
+    const installResult = run(
+      hstackPath,
+      ['self-host', 'install', '--channel=preview', '--mode=user', '--no-auto-update', '--non-interactive', '--without-cli', '--json'],
+      {
+        label: 'self-host-schtasks',
+        env: commonEnv,
+        timeoutMs: SELF_HOST_INSTALL_TIMEOUT_MS,
+        allowFail: true,
+        cwd: sandboxDir,
+      }
+    );
+    if ((installResult.status ?? 1) !== 0) {
+      const recoveredHealth = await waitForHealth(`http://127.0.0.1:${serverPort}/v1/version`, 120_000);
+      if (!recoveredHealth) {
+        const statusResult = run(
+          hstackPath,
+          ['self-host', 'status', '--channel=preview', '--mode=user', '--json'],
+          { label: 'self-host-schtasks', env: commonEnv, allowFail: true, timeoutMs: 60_000, cwd: sandboxDir }
+        );
+        const schtasksQuery = run('schtasks', ['/Query', '/TN', taskName, '/FO', 'LIST', '/V'], { label: 'self-host-schtasks', allowFail: true, timeoutMs: 20_000 });
+        const outTail = readTail(serverOutLog);
+        const errTail = readTail(serverErrLog);
+        throw new Error(
+          [
+            '[self-host-schtasks] 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()}`,
+            `self-host status:\n${String(statusResult.stdout ?? '').trim()}\n${String(statusResult.stderr ?? '').trim()}`,
+            `schtasks query (${taskName}):\n${String(schtasksQuery.stdout ?? '').trim()}\n${String(schtasksQuery.stderr ?? '').trim()}`,
+            `server out tail (${serverOutLog}):\n${String(outTail.stdout ?? '').trim()}\n${String(outTail.stderr ?? '').trim()}`,
+            `server err tail (${serverErrLog}):\n${String(errTail.stdout ?? '').trim()}\n${String(errTail.stderr ?? '').trim()}`,
+          ].join('\n\n')
+        );
+      }
+    }
+    installSucceeded = true;
+
+    const healthOk = await waitForHealth(`http://127.0.0.1:${serverPort}/v1/version`, 120_000);
+    assert.equal(healthOk, true, 'self-host service health endpoint did not become ready');
+
+    const status = run(
+      hstackPath,
+      ['self-host', 'status', '--channel=preview', '--mode=user', '--json'],
+      { label: 'self-host-schtasks', env: commonEnv, timeoutMs: 60_000, cwd: sandboxDir }
+    );
+    const statusPayload = JSON.parse(String(status.stdout ?? '').trim());
+    assert.equal(statusPayload?.ok, true);
+    assert.equal(statusPayload?.service?.name, serviceName);
+    assert.equal(statusPayload?.service?.active, true);
+    assert.equal(statusPayload?.healthy, true);
+
+    const schtasksQueryAfter = run('schtasks', ['/Query', '/TN', taskName], { label: 'self-host-schtasks', allowFail: true, timeoutMs: 20_000 });
+    assert.equal(schtasksQueryAfter.status, 0, 'schtasks query should succeed after install');
+
+    run(
+      hstackPath,
+      ['self-host', 'uninstall', '--channel=preview', '--mode=user', '--yes', '--purge-data', '--json'],
+      { label: 'self-host-schtasks', env: commonEnv, timeoutMs: 180_000, cwd: sandboxDir }
+    );
+    installSucceeded = false;
+
+    const schtasksAfterUninstall = run('schtasks', ['/Query', '/TN', taskName], { label: 'self-host-schtasks', allowFail: true, timeoutMs: 20_000 });
+    assert.notEqual(schtasksAfterUninstall.status, 0, 'scheduled task should not remain after uninstall');
+  }
+);

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 });