@happier-dev/stack 0.1.0-preview.96.1 → 0.2.0-preview.1775370152.55749

package/scripts/service.mjs

@@ -2,10 +2,12 @@ import './utils/env/env.mjs';
 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 { resolveServerUrls } from './utils/server/urls.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';
@@ -22,6 +24,13 @@ import {
   resolvePreferredStackDaemonStatePaths,
   resolveStackCredentialPaths,
 } from './utils/auth/credentials_paths.mjs';
+import {
+  resolveAutostartEnvFilePath,
+  resolveAutostartLogPaths,
+  resolveAutostartWorkingDirectory,
+} from './utils/service/stack_autostart_resolution.mjs';
+import { buildServiceAuthGuidance } from './utils/service/auth_guidance.mjs';
+import { recordStackRuntimeStopRequest } from './utils/stack/runtime_state.mjs';
 
 /**
  * Manage the autostart service installed by `hstack bootstrap -- --autostart`.
@@ -45,7 +54,7 @@ function getUid() {
   return Number.isFinite(n) ? n : null;
 }
 
-function getAutostartEnv({ rootDir, mode }) {
+function getAutostartEnv({ mode, systemUserHomeDir } = {}) {
   // IMPORTANT:
   // LaunchAgents should NOT bake the entire config into the plist, because that would require
   // reinstalling the service for any config change (server flavor, worktrees, ports, etc).
@@ -58,18 +67,20 @@ function getAutostartEnv({ rootDir, mode }) {
   // Main installs:
   // - default to the main stack env (outside the repo): ~/.happier/stacks/main/env
 
-  const stacksEnvFile = process.env.HAPPIER_STACK_ENV_FILE?.trim() ? process.env.HAPPIER_STACK_ENV_FILE.trim() : '';
-  const envFileRaw = stacksEnvFile || resolveStackEnvPath('main').envPath;
-
-  // For system services, prefer a dynamic %h-based default when no explicit env file is set.
-  // This avoids accidentally pinning root's stack env when the service will run as another user.
-  const envFile =
-    mode === 'system' && !stacksEnvFile
-      ? '%h/.happier/stacks/main/env'
-      : envFileRaw;
+  const explicitEnvFilePath = process.env.HAPPIER_STACK_ENV_FILE?.trim() ? process.env.HAPPIER_STACK_ENV_FILE.trim() : '';
+  const defaultMainEnvFilePath = resolveStackEnvPath('main').envPath;
+  const envFile = resolveAutostartEnvFilePath({
+    mode,
+    explicitEnvFilePath,
+    defaultMainEnvFilePath,
+    systemUserHomeDir,
+  });
 
   return {
     HAPPIER_STACK_ENV_FILE: envFile,
+    // Service-mode behavior: keep server/UI up and start the daemon only once auth exists.
+    HAPPIER_STACK_DAEMON_WAIT_FOR_AUTH: '1',
+    HAPPIER_STACK_SERVICE_MODE: '1',
   };
 }
 
@@ -109,6 +120,33 @@ function ensureLinuxSystemModeSupported({ mode }) {
   }
 }
 
+export 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', '--restart'];
+  return [process.execPath, resolveInstalledPath(rootDir, 'bin/hstack.mjs'), 'start', '--restart'];
+}
+
 export async function installService({ mode = 'user', systemUser = null } = {}) {
   if (isSandboxed() && !sandboxAllowsGlobalSideEffects()) {
     throw new Error(
@@ -118,12 +156,20 @@ 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 env = getAutostartEnv({ rootDir, mode });
+  const systemUserHomeDir = mode === 'system' && systemUser ? await resolveHomeDirForUser(systemUser) : '';
+  const defaults = getDefaultAutostartPaths();
+  const env = getAutostartEnv({ mode, systemUserHomeDir });
+  const { baseDir, stdoutPath, stderrPath } = resolveAutostartLogPaths({
+    mode,
+    hasStorageDirOverride: Boolean((process.env.HAPPIER_STACK_STORAGE_DIR ?? '').trim()),
+    systemUserHomeDir,
+    stackName: defaults.stackName,
+    defaultBaseDir: defaults.baseDir,
+    defaultStdoutPath: defaults.stdoutPath,
+    defaultStderrPath: defaults.stderrPath,
+  });
+  const { label } = defaults;
   // Ensure the env file exists so the service never points at a missing path.
   try {
     const envFile = env.HAPPIER_STACK_ENV_FILE;
@@ -137,17 +183,45 @@ export async function installService({ mode = 'user', systemUser = null } = {})
   } catch {
     // ignore
   }
+  const programArgs = await resolveStackAutostartProgramArgs({ rootDir, mode, systemUser });
+  const workingDirectory = resolveAutostartWorkingDirectory({
+    platform: process.platform,
+    mode,
+    defaultHomeDir: homedir(),
+    systemUserHomeDir,
+    baseDir,
+    installedCliRoot: resolveInstalledCliRoot(rootDir),
+  });
+
+  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 +231,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)')}`);
 }
@@ -185,109 +274,6 @@ function systemdUnitName() {
   return `${label}.service`;
 }
 
-function systemdUnitPath() {
-  return join(homedir(), '.config', 'systemd', 'user', systemdUnitName());
-}
-
-function systemdEnvLines(env) {
-  return Object.entries(env)
-    .map(([k, v]) => `Environment=${k}=${String(v)}`)
-    .join('\n');
-}
-
-async function ensureSystemdUserServiceEnabled({ rootDir, label, env }) {
-  const unitPath = systemdUnitPath();
-  await mkdir(dirname(unitPath), { recursive: true });
-  const hstackShim = join(getCanonicalHomeDir(), 'bin', 'hstack');
-  const entry = existsSync(hstackShim) ? hstackShim : join(rootDir, 'bin', 'hstack.mjs');
-  const exec = existsSync(hstackShim) ? entry : `${process.execPath} ${entry}`;
-
-  const unit = `[Unit]
-Description=Happier Stack (${label})
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-WorkingDirectory=%h
-${systemdEnvLines(env)}
-ExecStart=${exec} start
-Restart=always
-RestartSec=2
-
-[Install]
-WantedBy=default.target
-`;
-
-  await writeFile(unitPath, unit, 'utf-8');
-  await runCapture('systemctl', ['--user', 'daemon-reload']).catch(() => {});
-  await run('systemctl', ['--user', 'enable', '--now', systemdUnitName()]);
-}
-
-async function ensureSystemdSystemServiceEnabled({ rootDir, label, env, systemUser }) {
-  const { unitName, unitPath } = getSystemdUnitInfo({ mode: 'system' });
-  let userLine = '';
-  let hstackShim = join(getCanonicalHomeDir(), 'bin', 'hstack');
-  if (systemUser) {
-    const home = await resolveHomeDirForUser(systemUser);
-    if (home) {
-      hstackShim = join(home, '.happier-stack', 'bin', 'hstack');
-    }
-    userLine = `User=${systemUser}\n`;
-  }
-
-  const entry = existsSync(hstackShim) ? hstackShim : join(rootDir, 'bin', 'hstack.mjs');
-  const exec = existsSync(hstackShim) ? entry : `${process.execPath} ${entry}`;
-
-  const unit = `[Unit]
-Description=Happier Stack (${label})
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-${userLine}WorkingDirectory=%h
-${systemdEnvLines(env)}
-ExecStart=${exec} start
-Restart=always
-RestartSec=2
-
-[Install]
-WantedBy=multi-user.target
-`;
-
-  try {
-    await writeFile(unitPath, unit, 'utf-8');
-  } catch (e) {
-    const code = e && typeof e === 'object' && 'code' in e ? String(e.code) : '';
-    if (code === 'EACCES' || code === 'EPERM') {
-      throw new Error(`[local] --mode=system requires root (run with sudo).`);
-    }
-    throw e;
-  }
-  await runCapture('systemctl', ['daemon-reload']).catch(() => {});
-  await run('systemctl', ['enable', '--now', unitName]);
-}
-
-async function ensureSystemdUserServiceDisabled({ remove } = {}) {
-  await runCapture('systemctl', ['--user', 'disable', '--now', systemdUnitName()]).catch(() => {});
-  await runCapture('systemctl', ['--user', 'stop', systemdUnitName()]).catch(() => {});
-  if (remove) {
-    await rm(systemdUnitPath(), { force: true }).catch(() => {});
-    await runCapture('systemctl', ['--user', 'daemon-reload']).catch(() => {});
-  }
-}
-
-async function ensureSystemdSystemServiceDisabled({ remove } = {}) {
-  const { unitName, unitPath } = getSystemdUnitInfo({ mode: 'system' });
-  await runCapture('systemctl', ['disable', '--now', unitName]).catch(() => {});
-  await runCapture('systemctl', ['stop', unitName]).catch(() => {});
-  if (remove) {
-    await rm(unitPath, { force: true }).catch(() => {});
-    await runCapture('systemctl', ['daemon-reload']).catch(() => {});
-  }
-}
-
 async function systemdStatus() {
   await run('systemctl', ['--user', 'status', systemdUnitName(), '--no-pager']);
 }
@@ -387,7 +373,12 @@ async function postStartDiagnostics() {
   } catch {
     port = 3005;
   }
-  const { publicServerUrl: publicUrl } = getPublicServerUrlEnvOverride({ env: process.env, serverPort: port });
+  const resolvedUrls = await resolveServerUrls({ env: process.env, serverPort: port, allowEnable: false }).catch(() => null);
+  const publicUrl =
+    resolvedUrls?.publicServerUrl
+      ? String(resolvedUrls.publicServerUrl)
+      : getPublicServerUrlEnvOverride({ env: process.env, serverPort: port }).publicServerUrl;
+  const publicServerUrlSource = String(resolvedUrls?.publicServerUrlSource ?? '').trim();
 
   const cliDir = getComponentDir(rootDir, 'happier-cli');
   const cliBin = join(cliDir, 'bin', 'happier.mjs');
@@ -475,7 +466,12 @@ async function postStartDiagnostics() {
   console.log(banner('service', { subtitle: `Post-start diagnostics (${stackName})` }));
   console.log('');
 
-  const authCmd = stackName === 'main' ? 'hstack auth login' : `hstack stack auth ${stackName} login`;
+  const authGuidance = buildServiceAuthGuidance({
+    stackName,
+    publicServerUrl: publicUrl,
+    tailscaleServeEnabled: (process.env.HAPPIER_STACK_TAILSCALE_SERVE ?? '0') === '1',
+    publicServerUrlSource,
+  });
 
   if (res.ok && res.kind === 'running') {
     console.log(sectionTitle('Daemon'));
@@ -489,13 +485,37 @@ async function postStartDiagnostics() {
   } else if (!existingCredentialPath) {
     console.log(bullets([`${yellow('!')} auth required ${dim(`(missing ${accessKey})`)}`]));
     console.log('');
+    if (authGuidance.warnings.length > 0) {
+      console.log(sectionTitle('Warning'));
+      for (const w of authGuidance.warnings) {
+        console.log(w);
+        console.log('');
+      }
+    }
     console.log(sectionTitle('Authenticate'));
-    console.log(bullets([`${dim('run:')} ${cmdFmt(authCmd)}`]));
+    console.log(
+      bullets([
+        `${dim('headless (recommended):')} ${cmdFmt(authGuidance.headlessCmd)}`,
+        `${dim('laptop (web):')} ${cmdFmt(authGuidance.laptopCmd)}`,
+      ])
+    );
   } else if (res.kind === 'auth_required') {
     console.log(bullets([`${yellow('!')} waiting for auth ${dim(`(pid=${res.pid ?? 'unknown'})`)}`]));
     console.log('');
+    if (authGuidance.warnings.length > 0) {
+      console.log(sectionTitle('Warning'));
+      for (const w of authGuidance.warnings) {
+        console.log(w);
+        console.log('');
+      }
+    }
     console.log(sectionTitle('Authenticate'));
-    console.log(bullets([`${dim('run:')} ${cmdFmt(authCmd)}`]));
+    console.log(
+      bullets([
+        `${dim('headless (recommended):')} ${cmdFmt(authGuidance.headlessCmd)}`,
+        `${dim('laptop (web):')} ${cmdFmt(authGuidance.laptopCmd)}`,
+      ])
+    );
   } else {
     console.log(bullets([`${yellow('!')} not running`]));
   }
@@ -517,13 +537,26 @@ async function postStartDiagnostics() {
   }
 }
 
-async function stopLaunchAgent({ persistent }) {
+async function stopLaunchAgent({ persistent, requestedBy = 'service stop', reason = '' }) {
   const { plistPath } = getDefaultAutostartPaths();
   if (!existsSync(plistPath)) {
     // Service isn't installed for this stack (common for ad-hoc stacks). Treat as a no-op.
     return;
   }
 
+  const envFile = resolveAutostartEnvFilePath({
+    mode: 'user',
+    explicitEnvFilePath: process.env.HAPPIER_STACK_ENV_FILE?.trim() ? process.env.HAPPIER_STACK_ENV_FILE.trim() : '',
+    defaultMainEnvFilePath: resolveStackEnvPath('main').envPath,
+    systemUserHomeDir: null,
+  });
+  const runtimeStatePath = join(dirname(envFile), 'stack.runtime.json');
+  await recordStackRuntimeStopRequest(runtimeStatePath, {
+    signal: 'SIGTERM',
+    requestedBy,
+    reason,
+  }).catch(() => {});
+
   const { label } = getDefaultAutostartPaths();
 
   // Old-style
@@ -629,13 +662,18 @@ async function main() {
   const argv = process.argv.slice(2);
   const helpSepIdx = argv.indexOf('--');
   const helpScopeArgv = helpSepIdx === -1 ? argv : argv.slice(0, helpSepIdx);
+  const passthrough = helpSepIdx === -1 ? [] : argv.slice(helpSepIdx + 1);
   const mode = resolveServiceMode(helpScopeArgv);
   const systemUser = resolveSystemUser(helpScopeArgv);
   ensureLinuxSystemModeSupported({ mode });
+  const authNow =
+    helpScopeArgv.includes('--auth-now') ||
+    helpScopeArgv.includes('--auth');
 
-  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 rootDir = getRootDir(import.meta.url);
   const positionals = helpScopeArgv.filter((a) => a && a !== '--' && !a.startsWith('-'));
   const cmd = positionals[0] ?? 'help';
   const json = wantsJson(helpScopeArgv);
@@ -645,10 +683,10 @@ async function main() {
     ['install', 'hstack service install [--json]'],
     ['uninstall', 'hstack service uninstall [--json]'],
     ['status', 'hstack service status [--json]'],
-    ['start', 'hstack service start [--json]'],
+    ['start', 'hstack service start [--auth-now] [-- <auth login args...>] [--json]'],
     ['stop', 'hstack service stop [--json]'],
-    ['restart', 'hstack service restart [--json]'],
-    ['enable', 'hstack service enable [--json]'],
+    ['restart', 'hstack service restart [--auth-now] [-- <auth login args...>] [--json]'],
+    ['enable', 'hstack service enable [--auth-now] [-- <auth login args...>] [--json]'],
     ['disable', 'hstack service disable [--json]'],
     ['logs', 'hstack service logs [--json]'],
     ['tail', 'hstack service tail'],
@@ -676,8 +714,8 @@ async function main() {
         sectionTitle('usage:'),
         `  ${cyan('hstack service')} install|uninstall [--mode=system|user] [--system-user=<name>] [--json]`,
         `  ${cyan('hstack service')} status [--mode=system|user] [--json]`,
-        `  ${cyan('hstack service')} start|stop|restart [--mode=system|user] [--json]`,
-        `  ${cyan('hstack service')} enable|disable [--mode=system|user] [--json]`,
+        `  ${cyan('hstack service')} start|stop|restart [--mode=system|user] [--auth-now] [-- <auth login args...>] [--json]`,
+        `  ${cyan('hstack service')} enable|disable [--mode=system|user] [--auth-now] [-- <auth login args...>] [--json]`,
         `  ${cyan('hstack service')} logs [--mode=system|user] [--json]`,
         `  ${cyan('hstack service')} tail`,
         '',
@@ -711,7 +749,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 +784,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 +802,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 {
@@ -760,11 +820,23 @@ async function main() {
         }
       }
       await postStartDiagnostics();
+      if (authNow) {
+        await run(process.execPath, [join(rootDir, 'scripts', 'auth.mjs'), 'login', ...passthrough], {
+          cwd: rootDir,
+          env: process.env,
+        });
+      }
       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 });
+        await stopLaunchAgent({ persistent: false, requestedBy: 'service stop', reason: 'explicit service stop' });
       } else {
         if (mode === 'system') {
           const { unitName } = getSystemdUnitInfo({ mode });
@@ -776,9 +848,17 @@ 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 });
+          await stopLaunchAgent({ persistent: false, requestedBy: 'service restart', reason: 'explicit service restart' });
           await waitForLaunchAgentStopped();
           await startLaunchAgent({ persistent: false });
         }
@@ -791,9 +871,23 @@ async function main() {
         }
       }
       await postStartDiagnostics();
+      if (authNow) {
+        await run(process.execPath, [join(rootDir, 'scripts', 'auth.mjs'), 'login', ...passthrough], {
+          cwd: rootDir,
+          env: process.env,
+        });
+      }
       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 {
@@ -805,11 +899,24 @@ async function main() {
         }
       }
       await postStartDiagnostics();
+      if (authNow) {
+        await run(process.execPath, [join(rootDir, 'scripts', 'auth.mjs'), 'login', ...passthrough], {
+          cwd: rootDir,
+          env: process.env,
+        });
+      }
       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 });
+        await stopLaunchAgent({ persistent: true, requestedBy: 'service disable', reason: 'explicit service disable' });
       } else {
         if (mode === 'system') {
           const { unitName } = getSystemdUnitInfo({ mode });
@@ -821,6 +928,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 +950,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/service_autostart_program_args.test.mjs

@@ -0,0 +1,32 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+
+import * as serviceModule from './service.mjs';
+
+const scriptsDir = dirname(fileURLToPath(import.meta.url));
+const rootDir = scriptsDir;
+
+test('resolveStackAutostartProgramArgs uses the stable hstack shim with --restart', async (t) => {
+  assert.equal(typeof serviceModule.resolveStackAutostartProgramArgs, 'function');
+
+  const tmp = await mkdtemp(join(tmpdir(), 'stack-service-program-args-'));
+  const canonicalHomeDir = join(tmp, 'canonical-home');
+  const shimPath = join(canonicalHomeDir, 'bin', 'hstack');
+  await mkdir(join(canonicalHomeDir, 'bin'), { recursive: true });
+  await writeFile(shimPath, '#!/bin/sh\nexit 0\n', { mode: 0o755 });
+
+  const previousCanonicalHome = process.env.HAPPIER_STACK_CANONICAL_HOME_DIR;
+  process.env.HAPPIER_STACK_CANONICAL_HOME_DIR = canonicalHomeDir;
+  t.after(async () => {
+    if (previousCanonicalHome == null) delete process.env.HAPPIER_STACK_CANONICAL_HOME_DIR;
+    else process.env.HAPPIER_STACK_CANONICAL_HOME_DIR = previousCanonicalHome;
+    await rm(tmp, { recursive: true, force: true });
+  });
+
+  const programArgs = await serviceModule.resolveStackAutostartProgramArgs({ rootDir, mode: 'user', systemUser: null });
+  assert.deepEqual(programArgs, [shimPath, 'start', '--restart']);
+});

package/scripts/service_mode_help.test.mjs

@@ -11,6 +11,7 @@ test('hstack service --help documents systemd mode flag', async () => {
   const res = await runNode([join(rootDir, 'scripts', 'service.mjs'), '--help'], { cwd: rootDir, env: process.env });
   assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
   assert.match(res.stdout, /--mode=system\|user/);
+  assert.match(res.stdout, /--auth-now\b/, `expected help to mention --auth-now\nstdout:\n${res.stdout}`);
 });
 
 test('hstack service --help tolerates invalid mode values', async () => {