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

package/scripts/self_host_runtime.test.mjs

@@ -1,11 +1,28 @@
 import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, writeFile } from 'node:fs/promises';
 import test from 'node:test';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 
 import {
   parseSelfHostInvocation,
   pickReleaseAsset,
+  resolveMinisignPublicKeyText,
+  resolveSelfHostAutoUpdateDefault,
+  resolveSelfHostAutoUpdateIntervalMinutes,
+  resolveSelfHostHealthTimeoutMs,
+  resolveSelfHostDefaults,
+  renderUpdaterLaunchdPlistXml,
+  renderUpdaterScheduledTaskWrapperPs1,
+  renderUpdaterSystemdUnit,
+  renderUpdaterSystemdTimerUnit,
   renderServerEnvFile,
   renderServerServiceUnit,
+  renderSelfHostStatusText,
+  buildSelfHostDoctorChecks,
+  normalizeSelfHostAutoUpdateState,
+  decideSelfHostAutoUpdateReconcile,
+  mergeEnvTextWithDefaults,
 } from './self_host_runtime.mjs';
 
 test('parseSelfHostInvocation accepts optional self-host prefix', () => {
@@ -48,7 +65,37 @@ test('pickReleaseAsset rejects releases missing minisign signature assets', () =
       os: 'linux',
       arch: 'x64',
     });
-  }, /signature/i);
+  }, /minisig|signature/i);
+});
+
+test('pickReleaseAsset supports windows zip artifacts', () => {
+  const assets = [
+    { name: 'happier-server-v1.2.3-windows-x64.zip', browser_download_url: 'https://example.test/server.zip' },
+    { 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: 'windows',
+    arch: 'x64',
+  });
+  assert.equal(picked.archiveUrl, 'https://example.test/server.zip');
+});
+
+test('pickReleaseAsset supports windows tar.gz artifacts', () => {
+  const assets = [
+    { name: 'happier-server-v1.2.3-windows-x64.tar.gz', browser_download_url: 'https://example.test/server.tgz' },
+    { 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: 'windows',
+    arch: 'x64',
+  });
+  assert.equal(picked.archiveUrl, 'https://example.test/server.tgz');
 });
 
 test('renderServerServiceUnit references configured binary and env file', () => {
@@ -65,6 +112,19 @@ test('renderServerServiceUnit references configured binary and env file', () =>
   assert.match(unit, /StandardOutput=append:\/var\/log\/happier\/server.log/);
 });
 
+test('resolveSelfHostDefaults uses user-mode paths by default', () => {
+  const cfg = resolveSelfHostDefaults({ platform: 'linux', mode: 'user', homeDir: '/home/me' });
+  assert.equal(cfg.installRoot, '/home/me/.happier/self-host');
+  assert.equal(cfg.binDir, '/home/me/.happier/bin');
+  assert.equal(cfg.configDir, '/home/me/.happier/self-host/config');
+});
+
+test('resolveMinisignPublicKeyText prefers inline override and otherwise returns bundled key', () => {
+  const bundled = resolveMinisignPublicKeyText({});
+  assert.match(bundled, /minisign public key/i);
+  assert.equal(resolveMinisignPublicKeyText({ HAPPIER_MINISIGN_PUBKEY: 'hello' }), 'hello');
+});
+
 test('renderServerEnvFile emits sqlite/local defaults for self-host mode', () => {
   const envText = renderServerEnvFile({
     port: 3005,
@@ -74,9 +134,309 @@ test('renderServerEnvFile emits sqlite/local defaults for self-host mode', () =>
     dbDir: '/var/lib/happier/pglite',
   });
   assert.match(envText, /PORT=3005/);
+  assert.match(envText, /METRICS_ENABLED=false/);
   assert.match(envText, /HAPPIER_DB_PROVIDER=sqlite/);
+  assert.match(envText, /DATABASE_URL=file:\/var\/lib\/happier\/happier-server-light\.sqlite/);
   assert.match(envText, /HAPPIER_FILES_BACKEND=local/);
+  assert.match(envText, /HAPPIER_SQLITE_AUTO_MIGRATE=1/);
+  assert.match(envText, /HAPPIER_SQLITE_MIGRATIONS_DIR=\/var\/lib\/happier\/migrations\/sqlite/);
   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/);
 });
+
+test('renderServerEnvFile includes ui bundle directory when provided', () => {
+  const envText = renderServerEnvFile({
+    port: 3005,
+    host: '127.0.0.1',
+    dataDir: '/var/lib/happier',
+    filesDir: '/var/lib/happier/files',
+    dbDir: '/var/lib/happier/pglite',
+    uiDir: '/var/lib/happier/ui-web/current',
+  });
+  assert.match(envText, /HAPPIER_SERVER_UI_DIR=\/var\/lib\/happier\/ui-web\/current/);
+});
+
+test('renderServerEnvFile includes PRISMA_QUERY_ENGINE_LIBRARY when a packaged sqlite engine is present', async () => {
+  const serverBinDir = await mkdtemp(join(tmpdir(), 'happier-self-host-bin-'));
+  await mkdir(join(serverBinDir, 'generated', 'sqlite-client'), { recursive: true });
+  const enginePath = join(serverBinDir, 'generated', 'sqlite-client', 'libquery_engine-darwin-arm64.dylib.node');
+  await writeFile(enginePath, 'stub', 'utf-8');
+
+  const envText = renderServerEnvFile({
+    port: 3005,
+    host: '127.0.0.1',
+    platform: 'darwin',
+    arch: 'arm64',
+    serverBinDir,
+    dataDir: '/var/lib/happier',
+    filesDir: '/var/lib/happier/files',
+    dbDir: '/var/lib/happier/pglite',
+  });
+  assert.match(envText, /PRISMA_CLIENT_ENGINE_TYPE=library/);
+  assert.match(envText, new RegExp(`PRISMA_QUERY_ENGINE_LIBRARY=${enginePath.replaceAll('\\\\', '\\\\\\\\')}`));
+});
+
+test('renderServerEnvFile uses file URL semantics on Windows', () => {
+  const envText = renderServerEnvFile({
+    port: 3005,
+    host: '127.0.0.1',
+    platform: 'win32',
+    dataDir: 'C:\\\\Users\\\\me\\\\.happier\\\\self-host\\\\data',
+    filesDir: 'C:\\\\Users\\\\me\\\\.happier\\\\self-host\\\\data\\\\files',
+    dbDir: 'C:\\\\Users\\\\me\\\\.happier\\\\self-host\\\\data\\\\pglite',
+  });
+  assert.match(envText, /DATABASE_URL=file:\/\/\/C:\/Users\/me\/\.happier\/self-host\/data\/happier-server-light\.sqlite/);
+});
+
+test('resolveSelfHostHealthTimeoutMs defaults to a safe health timeout', () => {
+  assert.equal(resolveSelfHostHealthTimeoutMs({}), 90_000);
+});
+
+test('resolveSelfHostHealthTimeoutMs honors explicit timeout values >= 10s', () => {
+  assert.equal(resolveSelfHostHealthTimeoutMs({ HAPPIER_SELF_HOST_HEALTH_TIMEOUT_MS: '120000' }), 120_000);
+});
+
+test('resolveSelfHostHealthTimeoutMs ignores invalid or too-small values', () => {
+  assert.equal(resolveSelfHostHealthTimeoutMs({ HAPPIER_SELF_HOST_HEALTH_TIMEOUT_MS: 'abc' }), 90_000);
+  assert.equal(resolveSelfHostHealthTimeoutMs({ HAPPIER_SELF_HOST_HEALTH_TIMEOUT_MS: '5000' }), 90_000);
+});
+
+test('resolveSelfHostAutoUpdateDefault is opt-in (disabled by default)', () => {
+  assert.equal(resolveSelfHostAutoUpdateDefault({}), false);
+  assert.equal(resolveSelfHostAutoUpdateDefault({ HAPPIER_SELF_HOST_AUTO_UPDATE: '1' }), true);
+});
+
+test('resolveSelfHostAutoUpdateIntervalMinutes provides a safe default and bounds invalid values', () => {
+  assert.equal(resolveSelfHostAutoUpdateIntervalMinutes({}), 1440);
+  assert.equal(resolveSelfHostAutoUpdateIntervalMinutes({ HAPPIER_SELF_HOST_AUTO_UPDATE_INTERVAL_MINUTES: '60' }), 60);
+  assert.equal(resolveSelfHostAutoUpdateIntervalMinutes({ HAPPIER_SELF_HOST_AUTO_UPDATE_INTERVAL_MINUTES: '0' }), 1440);
+  assert.equal(resolveSelfHostAutoUpdateIntervalMinutes({ HAPPIER_SELF_HOST_AUTO_UPDATE_INTERVAL_MINUTES: 'abc' }), 1440);
+});
+
+test('renderUpdaterSystemdUnit runs self-host update without restart loops', () => {
+  const unit = renderUpdaterSystemdUnit({
+    updaterLabel: 'happier-server-updater',
+    hstackPath: '/home/me/.happier/bin/hstack',
+    channel: 'preview',
+    mode: 'user',
+    workingDirectory: '/home/me/.happier/self-host',
+    stdoutPath: '/home/me/.happier/self-host/logs/updater.out.log',
+    stderrPath: '/home/me/.happier/self-host/logs/updater.err.log',
+    wantedBy: 'default.target',
+  });
+  assert.match(unit, /ExecStart=\/home\/me\/\.happier\/bin\/hstack self-host update --channel=preview --mode=user --non-interactive/);
+  assert.match(unit, /Restart=no/);
+  assert.match(unit, /WantedBy=default\.target/);
+});
+
+test('renderUpdaterLaunchdPlistXml runs self-host update without keepalive loops', () => {
+  const plist = renderUpdaterLaunchdPlistXml({
+    updaterLabel: 'happier-server-updater',
+    hstackPath: '/Users/me/.happier/bin/hstack',
+    channel: 'preview',
+    mode: 'user',
+    intervalMinutes: 60,
+    workingDirectory: '/Users/me/.happier/self-host',
+    stdoutPath: '/Users/me/.happier/self-host/logs/updater.out.log',
+    stderrPath: '/Users/me/.happier/self-host/logs/updater.err.log',
+  });
+
+  assert.match(plist, /<key>RunAtLoad<\/key>\s*<true\/>/);
+  assert.match(plist, /<key>StartInterval<\/key>\s*<integer>3600<\/integer>/);
+  assert.doesNotMatch(plist, /<key>KeepAlive<\/key>/);
+  assert.match(plist, /<key>PATH<\/key>/);
+  assert.match(plist, /<string>\/Users\/me\/\.happier\/bin\/hstack<\/string>/);
+  assert.match(plist, /<string>self-host<\/string>/);
+  assert.match(plist, /<string>update<\/string>/);
+  assert.match(plist, /<string>--channel=preview<\/string>/);
+  assert.match(plist, /<string>--mode=user<\/string>/);
+  assert.match(plist, /<string>--non-interactive<\/string>/);
+});
+
+test('renderUpdaterSystemdTimerUnit schedules periodic updater runs', () => {
+  const timer = renderUpdaterSystemdTimerUnit({
+    updaterLabel: 'happier-server-updater',
+    intervalMinutes: 60,
+  });
+  assert.match(timer, /OnUnitActiveSec=60m/);
+  assert.match(timer, /Unit=happier-server-updater\.service/);
+  assert.match(timer, /WantedBy=timers\.target/);
+});
+
+test('renderUpdaterScheduledTaskWrapperPs1 runs self-host update without node dependencies', () => {
+  const wrapper = renderUpdaterScheduledTaskWrapperPs1({
+    updaterLabel: 'happier-server-updater',
+    hstackPath: 'C:\\\\Users\\\\me\\\\.happier\\\\bin\\\\hstack.exe',
+    channel: 'preview',
+    mode: 'user',
+    workingDirectory: 'C:\\\\Users\\\\me\\\\.happier\\\\self-host',
+    stdoutPath: 'C:\\\\Users\\\\me\\\\.happier\\\\self-host\\\\logs\\\\updater.out.log',
+    stderrPath: 'C:\\\\Users\\\\me\\\\.happier\\\\self-host\\\\logs\\\\updater.err.log',
+  });
+
+  assert.match(
+    wrapper,
+    /hstack\.exe"\s+"self-host"\s+"update"\s+"--channel=preview"\s+"--mode=user"\s+"--non-interactive"/i
+  );
+});
+
+test('mergeEnvTextWithDefaults preserves overrides while backfilling new default keys', () => {
+  const defaults = renderServerEnvFile({
+    port: 3005,
+    host: '127.0.0.1',
+    dataDir: '/var/lib/happier',
+    filesDir: '/var/lib/happier/files',
+    dbDir: '/var/lib/happier/pglite',
+  });
+  const existing = [
+    ...defaults
+      .split('\n')
+      .filter((line) => !line.startsWith('HAPPIER_SQLITE_AUTO_MIGRATE=') && !line.startsWith('HAPPIER_SQLITE_MIGRATIONS_DIR=')),
+    'PORT=7777',
+    'FOO=bar',
+    '',
+  ].join('\n');
+
+  const merged = mergeEnvTextWithDefaults(existing, defaults);
+  assert.match(merged, /PORT=7777/);
+  assert.match(merged, /HAPPIER_SQLITE_AUTO_MIGRATE=1/);
+  assert.match(merged, /HAPPIER_SQLITE_MIGRATIONS_DIR=\/var\/lib\/happier\/migrations\/sqlite/);
+  assert.match(merged, /FOO=bar/);
+});
+
+test('renderSelfHostStatusText reports versions, health, and auto-update config separately from job state', () => {
+  const text = renderSelfHostStatusText(
+    {
+      channel: 'preview',
+      mode: 'user',
+      serviceName: 'happier-server',
+      serverUrl: 'http://127.0.0.1:3005',
+      healthy: true,
+      service: { active: true, enabled: true },
+      versions: { server: '1.2.3-preview.1', uiWeb: '9.9.9-preview.2' },
+      autoUpdate: {
+        label: 'happier-server-updater',
+        job: { active: true, enabled: true },
+        configured: { enabled: true, intervalMinutes: 60 },
+      },
+      updatedAt: '2026-02-15T00:00:00.000Z',
+    },
+    { colors: false },
+  );
+
+  assert.match(text, /channel:\s*preview/);
+  assert.match(text, /mode:\s*user/);
+  assert.match(text, /url:\s*http:\/\/127\.0\.0\.1:3005/);
+  assert.match(text, /health:\s*ok/);
+  assert.match(text, /server:\s*1\.2\.3-preview\.1/);
+  assert.match(text, /ui-web:\s*9\.9\.9-preview\.2/);
+  assert.match(text, /auto-update:\s*configured enabled \(every 60m\); job enabled, active/);
+  assert.match(text, /updated:\s*2026-02-15T00:00:00\.000Z/);
+});
+
+test('renderSelfHostStatusText shows disabled auto-update config even if job state is unknown', () => {
+  const text = renderSelfHostStatusText(
+    {
+      channel: 'stable',
+      mode: 'user',
+      serviceName: 'happier-server',
+      serverUrl: 'http://127.0.0.1:3005',
+      healthy: false,
+      service: { active: null, enabled: null },
+      versions: { server: null, uiWeb: null },
+      autoUpdate: {
+        label: 'happier-server-updater',
+        job: { active: null, enabled: null },
+        configured: { enabled: false, intervalMinutes: 1440 },
+      },
+      updatedAt: null,
+    },
+    { colors: false },
+  );
+
+  assert.match(text, /auto-update:\s*configured disabled; job unknown/);
+  assert.match(text, /health:\s*failed/);
+});
+
+test('buildSelfHostDoctorChecks does not require external minisign and includes ui-web checks when installed', () => {
+  const checks = buildSelfHostDoctorChecks(
+    {
+      platform: 'linux',
+      mode: 'user',
+      serverBinaryPath: '/home/me/.happier/self-host/bin/happier-server',
+      configEnvPath: '/home/me/.happier/self-host/config/server.env',
+      uiWebCurrentDir: '/home/me/.happier/self-host/ui-web/current',
+    },
+    {
+      state: { uiWeb: { installed: true } },
+      commandExists: (name) => new Set(['tar', 'systemctl']).has(name),
+      pathExists: (p) => p.endsWith('happier-server') || p.endsWith('server.env') || p.endsWith('index.html'),
+    },
+  );
+
+  assert.ok(checks.find((c) => c.name === 'tar')?.ok);
+  assert.ok(checks.find((c) => c.name === 'systemctl')?.ok);
+  assert.equal(checks.some((c) => c.name === 'minisign'), false);
+  assert.ok(checks.find((c) => c.name === 'ui-web')?.ok);
+});
+
+test('buildSelfHostDoctorChecks flags missing ui-web bundle when state expects ui-web installed', () => {
+  const checks = buildSelfHostDoctorChecks(
+    {
+      platform: 'linux',
+      mode: 'user',
+      serverBinaryPath: '/home/me/.happier/self-host/bin/happier-server',
+      configEnvPath: '/home/me/.happier/self-host/config/server.env',
+      uiWebCurrentDir: '/home/me/.happier/self-host/ui-web/current',
+    },
+    {
+      state: { uiWeb: { installed: true } },
+      commandExists: () => true,
+      pathExists: (p) => !p.endsWith('index.html'),
+    },
+  );
+
+  assert.equal(checks.find((c) => c.name === 'ui-web')?.ok, false);
+});
+
+test('normalizeSelfHostAutoUpdateState upgrades legacy boolean config to structured config', () => {
+  assert.deepEqual(
+    normalizeSelfHostAutoUpdateState({ autoUpdate: true }, { fallbackIntervalMinutes: 1440 }),
+    { enabled: true, intervalMinutes: 1440 },
+  );
+  assert.deepEqual(
+    normalizeSelfHostAutoUpdateState({ autoUpdate: false }, { fallbackIntervalMinutes: 1440 }),
+    { enabled: false, intervalMinutes: 1440 },
+  );
+});
+
+test('normalizeSelfHostAutoUpdateState preserves explicit interval and bounds invalid values', () => {
+  assert.deepEqual(
+    normalizeSelfHostAutoUpdateState({ autoUpdate: { enabled: true, intervalMinutes: 60 } }, { fallbackIntervalMinutes: 1440 }),
+    { enabled: true, intervalMinutes: 60 },
+  );
+  assert.deepEqual(
+    normalizeSelfHostAutoUpdateState({ autoUpdate: { enabled: true, intervalMinutes: 0 } }, { fallbackIntervalMinutes: 1440 }),
+    { enabled: true, intervalMinutes: 1440 },
+  );
+  assert.deepEqual(
+    normalizeSelfHostAutoUpdateState({}, { fallbackIntervalMinutes: 1440 }),
+    { enabled: false, intervalMinutes: 1440 },
+  );
+});
+
+test('decideSelfHostAutoUpdateReconcile maps configured state to an install/uninstall action', () => {
+  assert.deepEqual(
+    decideSelfHostAutoUpdateReconcile({ autoUpdate: true }, { fallbackIntervalMinutes: 1440 }),
+    { action: 'install', enabled: true, intervalMinutes: 1440 },
+  );
+  assert.deepEqual(
+    decideSelfHostAutoUpdateReconcile({ autoUpdate: false }, { fallbackIntervalMinutes: 1440 }),
+    { action: 'uninstall', enabled: false, intervalMinutes: 1440 },
+  );
+  assert.deepEqual(
+    decideSelfHostAutoUpdateReconcile({}, { fallbackIntervalMinutes: 1440 }),
+    { action: 'uninstall', enabled: false, intervalMinutes: 1440 },
+  );
+});

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