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

package/scripts/utils/service/service_manager.definition.test.mjs

@@ -0,0 +1,66 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { buildServiceDefinition } from './service_manager.mjs';
+
+test('buildServiceDefinition renders a systemd user unit definition', () => {
+  const def = buildServiceDefinition({
+    backend: 'systemd-user',
+    homeDir: '/home/me',
+    spec: {
+      label: 'dev.happier.selfhost',
+      description: 'Happier Self-Host',
+      programArgs: ['/home/me/.happier/self-host/bin/happier-server'],
+      workingDirectory: '/home/me/.happier/self-host',
+      env: { PORT: '3005' },
+      stdoutPath: '/home/me/.happier/self-host/logs/server.out.log',
+      stderrPath: '/home/me/.happier/self-host/logs/server.err.log',
+    },
+  });
+
+  assert.equal(def.kind, 'systemd-service');
+  assert.equal(def.path, '/home/me/.config/systemd/user/dev.happier.selfhost.service');
+  assert.match(def.contents, /ExecStart=\/home\/me\/\.happier\/self-host\/bin\/happier-server/);
+});
+
+test('buildServiceDefinition renders a launchd user plist definition', () => {
+  const def = buildServiceDefinition({
+    backend: 'launchd-user',
+    homeDir: '/Users/me',
+    spec: {
+      label: 'dev.happier.selfhost',
+      description: 'Happier Self-Host',
+      programArgs: ['/Users/me/.happier/self-host/bin/happier-server'],
+      workingDirectory: '/Users/me/.happier/self-host',
+      env: { PORT: '3005' },
+      stdoutPath: '/Users/me/.happier/self-host/logs/server.out.log',
+      stderrPath: '/Users/me/.happier/self-host/logs/server.err.log',
+    },
+  });
+
+  assert.equal(def.kind, 'launchd-plist');
+  assert.equal(def.path, '/Users/me/Library/LaunchAgents/dev.happier.selfhost.plist');
+  assert.match(def.contents, /<key>Label<\/key>/);
+  assert.match(def.contents, /dev\.happier\.selfhost/);
+});
+
+test('buildServiceDefinition renders a windows scheduled-task wrapper', () => {
+  const def = buildServiceDefinition({
+    backend: 'schtasks-user',
+    homeDir: 'C:\\\\Users\\\\me',
+    spec: {
+      label: 'dev.happier.selfhost',
+      description: 'Happier Self-Host',
+      programArgs: ['C:\\\\Users\\\\me\\\\.happier\\\\self-host\\\\bin\\\\happier-server.exe'],
+      workingDirectory: 'C:\\\\Users\\\\me\\\\.happier\\\\self-host',
+      env: { PORT: '3005' },
+      stdoutPath: 'C:\\\\Users\\\\me\\\\.happier\\\\self-host\\\\logs\\\\server.out.log',
+      stderrPath: 'C:\\\\Users\\\\me\\\\.happier\\\\self-host\\\\logs\\\\server.err.log',
+    },
+  });
+
+  assert.equal(def.kind, 'windows-wrapper-ps1');
+  assert.match(def.path, /dev\.happier\.selfhost\.ps1$/);
+  assert.match(def.contents, /\$env:PORT = "3005"/);
+});
+

package/scripts/utils/service/service_manager.mjs

@@ -0,0 +1,96 @@
+import { rm } from 'node:fs/promises';
+
+import {
+  resolveServiceBackend,
+  buildServiceDefinition,
+  planServiceAction,
+  applyServicePlan,
+} from '@happier-dev/cli-common/service';
+
+export { resolveServiceBackend, buildServiceDefinition, planServiceAction };
+
+function normalizeLabel(spec) {
+  const label = String(spec?.label ?? '').trim();
+  if (!label) throw new Error('[service] missing label');
+  return label;
+}
+
+function taskNameFor({ backend, label }) {
+  if (String(backend).startsWith('schtasks-')) {
+    return `Happier\\${label}`;
+  }
+  return '';
+}
+
+export async function installService({
+  platform = process.platform,
+  mode = 'user',
+  homeDir = '',
+  spec,
+  persistent = true,
+  uid = null,
+} = {}) {
+  const label = normalizeLabel(spec);
+  const backend = resolveServiceBackend({ platform, mode });
+  const definition = buildServiceDefinition({ backend, homeDir, spec });
+  const taskName = taskNameFor({ backend, label });
+
+  const plan = planServiceAction({
+    backend,
+    action: 'install',
+    label,
+    definitionPath: definition.path,
+    definitionContents: definition.contents,
+    taskName,
+    persistent,
+    uid,
+  });
+  await applyServicePlan(plan);
+  return { backend, definitionPath: definition.path, taskName: taskName || null };
+}
+
+export async function uninstallService({
+  platform = process.platform,
+  mode = 'user',
+  homeDir = '',
+  spec,
+  persistent = true,
+  uid = null,
+} = {}) {
+  const label = normalizeLabel(spec);
+  const backend = resolveServiceBackend({ platform, mode });
+  const definition = buildServiceDefinition({ backend, homeDir, spec });
+  const taskName = taskNameFor({ backend, label });
+
+  const plan = planServiceAction({
+    backend,
+    action: 'uninstall',
+    label,
+    definitionPath: definition.path,
+    definitionContents: definition.contents,
+    taskName,
+    persistent,
+    uid,
+  });
+  await applyServicePlan(plan);
+  await rm(definition.path, { force: true }).catch(() => {});
+  return { backend, taskName: taskName || null };
+}
+
+export async function restartService({ platform = process.platform, mode = 'user', spec, persistent = true, uid = null } = {}) {
+  const label = normalizeLabel(spec);
+  const backend = resolveServiceBackend({ platform, mode });
+  const taskName = taskNameFor({ backend, label });
+
+  const plan = planServiceAction({
+    backend,
+    action: 'restart',
+    label,
+    taskName,
+    persistent,
+    uid,
+  });
+  await applyServicePlan(plan);
+  return { backend };
+}
+

package/scripts/utils/service/service_manager.plan.test.mjs

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { planServiceAction } from './service_manager.mjs';
+
+test('planServiceAction plans a systemd user install', () => {
+  const plan = planServiceAction({
+    backend: 'systemd-user',
+    action: 'install',
+    label: 'dev.happier.selfhost',
+    definitionPath: '/home/me/.config/systemd/user/dev.happier.selfhost.service',
+    definitionContents: '[Unit]\nDescription=x\n',
+    persistent: true,
+  });
+
+  assert.equal(plan.writes.length, 1);
+  assert.equal(plan.writes[0].path, '/home/me/.config/systemd/user/dev.happier.selfhost.service');
+  assert.ok(plan.commands.some((c) => c.cmd === 'systemctl' && c.args.includes('--user') && c.args.includes('daemon-reload')));
+  assert.ok(plan.commands.some((c) => c.cmd === 'systemctl' && c.args.includes('--user') && c.args.includes('enable')));
+});
+
+test('planServiceAction plans a windows task install', () => {
+  const plan = planServiceAction({
+    backend: 'schtasks-user',
+    action: 'install',
+    label: 'dev.happier.selfhost',
+    taskName: 'Happier\\dev.happier.selfhost',
+    definitionPath: 'C:\\\\Users\\\\me\\\\.happier\\\\services\\\\dev.happier.selfhost.ps1',
+    definitionContents: 'Set-Location -LiteralPath "C:\\\\Users\\\\me"',
+    persistent: true,
+  });
+
+  assert.equal(plan.writes.length, 1);
+  assert.ok(plan.commands.some((c) => c.cmd === 'schtasks' && c.args.includes('/Create')));
+  assert.ok(plan.commands.some((c) => c.cmd === 'schtasks' && c.args.includes('/Run')));
+});
+

package/scripts/utils/service/service_manager.test.mjs

@@ -0,0 +1,20 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { resolveServiceBackend } from './service_manager.mjs';
+
+test('resolveServiceBackend selects launchd for darwin', () => {
+  assert.equal(resolveServiceBackend({ platform: 'darwin', mode: 'user' }), 'launchd-user');
+  assert.equal(resolveServiceBackend({ platform: 'darwin', mode: 'system' }), 'launchd-system');
+});
+
+test('resolveServiceBackend selects systemd for linux', () => {
+  assert.equal(resolveServiceBackend({ platform: 'linux', mode: 'user' }), 'systemd-user');
+  assert.equal(resolveServiceBackend({ platform: 'linux', mode: 'system' }), 'systemd-system');
+});
+
+test('resolveServiceBackend selects schtasks for windows', () => {
+  assert.equal(resolveServiceBackend({ platform: 'win32', mode: 'user' }), 'schtasks-user');
+  assert.equal(resolveServiceBackend({ platform: 'win32', mode: 'system' }), 'schtasks-system');
+});
+

package/scripts/utils/service/systemd_service_unit.mjs

@@ -0,0 +1 @@
+export { renderSystemdServiceUnit } from '@happier-dev/cli-common/service';

package/scripts/utils/service/systemd_service_unit.test.mjs

@@ -0,0 +1,42 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { renderSystemdServiceUnit } from './systemd_service_unit.mjs';
+
+test('renderSystemdServiceUnit emits a minimal systemd unit with env + working dir', () => {
+  const unit = renderSystemdServiceUnit({
+    description: 'Happier Self-Host',
+    execStart: '/home/me/.happier/self-host/bin/happier-server',
+    workingDirectory: '/home/me/.happier/self-host',
+    env: {
+      PORT: '3005',
+      HAPPIER_DB_PROVIDER: 'sqlite',
+    },
+    restart: 'on-failure',
+    stdoutPath: '/home/me/.happier/self-host/logs/server.out.log',
+    stderrPath: '/home/me/.happier/self-host/logs/server.err.log',
+  });
+
+  assert.match(unit, /^\[Unit\]/m);
+  assert.match(unit, /Description=Happier Self-Host/);
+  assert.match(unit, /WorkingDirectory=\/home\/me\/\.happier\/self-host/);
+  assert.match(unit, /ExecStart=\/home\/me\/\.happier\/self-host\/bin\/happier-server/);
+  assert.match(unit, /Environment=PORT=3005/);
+  assert.match(unit, /Environment=HAPPIER_DB_PROVIDER=sqlite/);
+  assert.match(unit, /Restart=on-failure/);
+  assert.match(unit, /StandardOutput=append:\/home\/me\/\.happier\/self-host\/logs\/server\.out\.log/);
+  assert.match(unit, /StandardError=append:\/home\/me\/\.happier\/self-host\/logs\/server\.err\.log/);
+});
+
+test('renderSystemdServiceUnit supports system mode User= lines', () => {
+  const unit = renderSystemdServiceUnit({
+    description: 'Happier Stack',
+    execStart: '/opt/happier/bin/hstack start',
+    workingDirectory: '%h',
+    env: { HAPPIER_STACK_ENV_FILE: '%h/.happier/stacks/main/env' },
+    restart: 'always',
+    runAsUser: 'happier',
+  });
+
+  assert.match(unit, /\nUser=happier\n/);
+});

package/scripts/utils/service/windows_schtasks_wrapper.mjs

@@ -0,0 +1 @@
+export { renderWindowsScheduledTaskWrapperPs1 } from '@happier-dev/cli-common/service';

package/scripts/utils/service/windows_schtasks_wrapper.test.mjs

@@ -0,0 +1,25 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { renderWindowsScheduledTaskWrapperPs1 } from './windows_schtasks_wrapper.mjs';
+
+test('renderWindowsScheduledTaskWrapperPs1 emits a wrapper that sets env and runs program args', () => {
+  const ps1 = renderWindowsScheduledTaskWrapperPs1({
+    workingDirectory: 'C:\\\\Users\\\\me\\\\.happier\\\\self-host',
+    programArgs: ['C:\\\\Users\\\\me\\\\.happier\\\\self-host\\\\bin\\\\happier-server.exe'],
+    env: {
+      PORT: '3005',
+      HAPPIER_DB_PROVIDER: 'sqlite',
+    },
+    stdoutPath: 'C:\\\\Users\\\\me\\\\.happier\\\\self-host\\\\logs\\\\server.out.log',
+    stderrPath: 'C:\\\\Users\\\\me\\\\.happier\\\\self-host\\\\logs\\\\server.err.log',
+  });
+
+  assert.match(ps1, /Set-Location -LiteralPath/);
+  assert.match(ps1, /\$env:PORT = "3005"/);
+  assert.match(ps1, /\$env:HAPPIER_DB_PROVIDER = "sqlite"/);
+  assert.match(ps1, /& "C:\\\\Users\\\\me\\\\.happier\\\\self-host\\\\bin\\\\happier-server\.exe"/);
+  assert.match(ps1, /1>> "C:\\\\Users\\\\me\\\\.happier\\\\self-host\\\\logs\\\\server\.out\.log"/);
+  assert.match(ps1, /2>> "C:\\\\Users\\\\me\\\\.happier\\\\self-host\\\\logs\\\\server\.err\.log"/);
+});
+

package/scripts/utils/ui/ui_export_env.mjs

@@ -0,0 +1,29 @@
+export function buildStackWebExportEnv({ baseEnv } = {}) {
+  const env = { ...(baseEnv || process.env) };
+
+  // This is a stack-built bundle (served by the stack server), so ensure the app
+  // behaves like stack context at runtime (no Cloud seeding/locking).
+  env.NODE_ENV = 'production';
+  env.EXPO_PUBLIC_DEBUG = '0';
+  env.EXPO_PUBLIC_HAPPY_SERVER_CONTEXT = 'stack';
+
+  // Leave empty so the web bundle uses window.location.origin at runtime.
+  env.EXPO_PUBLIC_HAPPY_SERVER_URL = '';
+
+  return env;
+}
+
+export function buildStackTauriExportEnv({ baseEnv, tauriServerUrl } = {}) {
+  const env = { ...(baseEnv || process.env) };
+
+  env.NODE_ENV = 'production';
+  env.EXPO_PUBLIC_DEBUG = '0';
+  env.EXPO_PUBLIC_HAPPY_SERVER_CONTEXT = 'stack';
+
+  // In Tauri, window.location.origin is a tauri:// origin, so hardcode the API base.
+  env.EXPO_PUBLIC_HAPPY_SERVER_URL = String(tauriServerUrl || '').trim();
+  env.EXPO_PUBLIC_SERVER_URL = env.EXPO_PUBLIC_HAPPY_SERVER_URL;
+
+  return env;
+}
+

package/scripts/utils/ui/ui_export_env.test.mjs

@@ -0,0 +1,25 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { buildStackTauriExportEnv, buildStackWebExportEnv } from './ui_export_env.mjs';
+
+test('buildStackWebExportEnv forces stack server context and leaves server URL empty for runtime origin', () => {
+  const env = buildStackWebExportEnv({ baseEnv: { ...process.env } });
+
+  assert.equal(env.NODE_ENV, 'production');
+  assert.equal(env.EXPO_PUBLIC_DEBUG, '0');
+  assert.equal(env.EXPO_PUBLIC_HAPPY_SERVER_CONTEXT, 'stack');
+  assert.equal(env.EXPO_PUBLIC_HAPPY_SERVER_URL, '');
+});
+
+test('buildStackTauriExportEnv forces stack server context and hardcodes API base URL', () => {
+  const tauriServerUrl = 'http://127.0.0.1:3013';
+  const env = buildStackTauriExportEnv({ baseEnv: { ...process.env }, tauriServerUrl });
+
+  assert.equal(env.NODE_ENV, 'production');
+  assert.equal(env.EXPO_PUBLIC_DEBUG, '0');
+  assert.equal(env.EXPO_PUBLIC_HAPPY_SERVER_CONTEXT, 'stack');
+  assert.equal(env.EXPO_PUBLIC_HAPPY_SERVER_URL, tauriServerUrl);
+  assert.equal(env.EXPO_PUBLIC_SERVER_URL, tauriServerUrl);
+});
+

package/scripts/worktrees.mjs

@@ -1981,6 +1981,9 @@ async function main() {
   const effectiveArgv = (() => {
     if (!commandsNeedingComponent.has(cmd)) return argv;
     const pos = argv.filter((a) => !a.startsWith('--'));
+    // Keep no-arg invocations untouched so handlers can apply their own defaults
+    // (for example: `wt status` should target the active repo, not a legacy component token).
+    if (pos.length <= 1) return argv;
     const maybeComponent = (pos[1] ?? '').trim();
     if (legacyComponents.has(maybeComponent)) return argv;
     // Insert the default component right after the command; legacy command handlers keep working.

package/scripts/worktrees_status_default_target.test.mjs

@@ -0,0 +1,56 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { runCommandCapture, runNodeCapture } from './testkit/stack_script_command_testkit.mjs';
+
+async function git(dir, args, env) {
+  const res = await runCommandCapture('git', args, { cwd: dir, env });
+  assert.equal(res.code, 0, `git ${args.join(' ')} failed\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+}
+
+test('hstack wt status defaults to active repo dir when no worktree spec is provided', async (t) => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-wt-status-default-'));
+  t.after(async () => {
+    await rm(tmp, { recursive: true, force: true }).catch(() => {});
+  });
+
+  const workspaceDir = join(tmp, 'workspace');
+  const homeDir = join(tmp, 'home');
+  const repoDir = join(workspaceDir, 'dev');
+  await mkdir(repoDir, { recursive: true });
+
+  const gitEnv = {
+    ...process.env,
+    GIT_AUTHOR_NAME: 'QA',
+    GIT_AUTHOR_EMAIL: 'qa@example.com',
+    GIT_COMMITTER_NAME: 'QA',
+    GIT_COMMITTER_EMAIL: 'qa@example.com',
+  };
+  await git(repoDir, ['init'], gitEnv);
+  await writeFile(join(repoDir, 'README.md'), '# repo\n', 'utf-8');
+  await git(repoDir, ['add', 'README.md'], gitEnv);
+  await git(repoDir, ['commit', '-m', 'init'], gitEnv);
+
+  const env = {
+    ...process.env,
+    HAPPIER_STACK_HOME_DIR: homeDir,
+    HAPPIER_STACK_WORKSPACE_DIR: workspaceDir,
+    HAPPIER_STACK_REPO_DIR: repoDir,
+    HAPPIER_STACK_OWNER: 'test',
+  };
+
+  const res = await runNodeCapture([join(rootDir, 'scripts', 'worktrees.mjs'), 'status', '--json'], {
+    cwd: rootDir,
+    env,
+  });
+
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  const parsed = JSON.parse(res.stdout);
+  assert.equal(parsed.dir, repoDir);
+});