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

package/scripts/remote_cmd.mjs

@@ -0,0 +1,240 @@
+import './utils/env/env.mjs';
+
+import { run, runCapture } from './utils/proc/proc.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
+
+function takeFlagValue(args, name) {
+  const rest = [];
+  let value = null;
+
+  for (let i = 0; i < args.length; i += 1) {
+    const a = String(args[i] ?? '');
+    if (a === name) {
+      const next = String(args[i + 1] ?? '');
+      if (!next || next.startsWith('--')) {
+        throw new Error(`Missing value for ${name}`);
+      }
+      value = next;
+      i += 1;
+      continue;
+    }
+    if (a.startsWith(`${name}=`)) {
+      const v = a.slice(`${name}=`.length);
+      if (!v) throw new Error(`Missing value for ${name}`);
+      value = v;
+      continue;
+    }
+    rest.push(a);
+  }
+
+  return { value, rest };
+}
+
+function safeBashSingleQuote(s) {
+  const raw = String(s ?? '');
+  if (raw === '') return "''";
+  // Wrap in single quotes and escape embedded single quotes safely.
+  // bash: 'foo'\''bar'
+  return `'${raw.replaceAll("'", `'\"'\"'`)}'`;
+}
+
+function parseJsonLinesBestEffort(stdout) {
+  const out = String(stdout ?? '');
+  const lines = out
+    .split(/\r?\n/)
+    .map((l) => l.trim())
+    .filter(Boolean);
+  for (const line of lines) {
+    try {
+      return JSON.parse(line);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+async function runSsh({ target, command }) {
+  await run('ssh', [target, 'bash', '-lc', command], { env: process.env });
+}
+
+async function runSshJson({ target, command }) {
+  const out = await runCapture('ssh', [target, 'bash', '-lc', command], { env: process.env });
+  const parsed = parseJsonLinesBestEffort(out);
+  if (!parsed) {
+    throw new Error('Remote command did not return valid JSON');
+  }
+  return parsed;
+}
+
+async function runLocalJson({ args }) {
+  const out = await runCapture('happier', args, { env: process.env });
+  const parsed = parseJsonLinesBestEffort(out);
+  if (!parsed) {
+    throw new Error('Local command did not return valid JSON');
+  }
+  return parsed;
+}
+
+function usageText() {
+  return [
+    '[remote] usage:',
+    '  hstack remote daemon setup --ssh <user@host> [--preview|--stable] [--channel <stable|preview>]',
+    '    [--service <user|none>]',
+    '    [--server-url=<url>] [--webapp-url=<url>] [--public-server-url=<url>]',
+    '    [--json]',
+    '',
+    'notes:',
+    '  - This command runs remote operations over ssh.',
+    '  - It installs the Happier CLI on the remote host, pairs credentials, and optionally installs/starts the daemon service.',
+    '  - Default service mode is user; set --service none to skip daemon service setup.',
+  ].join('\n');
+}
+
+function resolveChannel(argv) {
+  if (argv.includes('--preview')) return 'preview';
+  if (argv.includes('--stable')) return 'stable';
+  const picked = argv.find((a) => a === '--channel' || a.startsWith('--channel='));
+  if (!picked) return 'stable';
+  if (picked === '--channel') {
+    const idx = argv.indexOf('--channel');
+    const v = String(argv[idx + 1] ?? '').trim();
+    return v || 'stable';
+  }
+  const v = String(picked.slice('--channel='.length)).trim();
+  return v || 'stable';
+}
+
+function resolveService(argv) {
+  const picked = argv.find((a) => a === '--service' || a.startsWith('--service='));
+  if (!picked) return 'user';
+  if (picked === '--service') {
+    const idx = argv.indexOf('--service');
+    const v = String(argv[idx + 1] ?? '').trim().toLowerCase();
+    return v || 'user';
+  }
+  const v = String(picked.slice('--service='.length)).trim().toLowerCase();
+  return v || 'user';
+}
+
+async function runRemoteDaemonSetup(argvRaw) {
+  const argv0 = argvRaw.slice();
+  const json = wantsJson(argv0);
+
+  let args = argv0.slice();
+  const ssh = takeFlagValue(args, '--ssh');
+  args = ssh.rest;
+  if (!ssh.value) {
+    process.stderr.write('Missing required flag: --ssh <user@host>\n');
+    process.exit(2);
+  }
+
+  const channel = resolveChannel(argv0);
+  if (channel !== 'stable' && channel !== 'preview') {
+    throw new Error(`[remote] invalid --channel value: ${channel}`);
+  }
+
+  const service = resolveService(argv0);
+  if (service !== 'user' && service !== 'none') {
+    throw new Error(`[remote] invalid --service value: ${service} (expected user or none)`);
+  }
+
+  const serverUrlFlag = takeFlagValue(args, '--server-url');
+  args = serverUrlFlag.rest;
+  const webappUrlFlag = takeFlagValue(args, '--webapp-url');
+  args = webappUrlFlag.rest;
+  const publicServerUrlFlag = takeFlagValue(args, '--public-server-url');
+  args = publicServerUrlFlag.rest;
+
+  const serverFlags = {
+    serverUrl: serverUrlFlag.value,
+    webappUrl: webappUrlFlag.value,
+    publicServerUrl: publicServerUrlFlag.value,
+    localArgs: [
+      ...(serverUrlFlag.value ? [`--server-url=${serverUrlFlag.value}`] : []),
+      ...(webappUrlFlag.value ? [`--webapp-url=${webappUrlFlag.value}`] : []),
+      ...(publicServerUrlFlag.value ? [`--public-server-url=${publicServerUrlFlag.value}`] : []),
+    ],
+  };
+
+  const installUrl = 'https://happier.dev/install';
+  const remoteBin = '$HOME/.happier/bin/happier';
+
+  // Always disable auto-service setup in the installer so this command controls service behavior.
+  const installCmd = [
+    `curl -fsSL ${installUrl} |`,
+    `HAPPIER_CHANNEL=${channel} HAPPIER_WITH_DAEMON=0 HAPPIER_NONINTERACTIVE=1 bash`,
+  ].join(' ');
+
+  await runSsh({ target: ssh.value, command: installCmd });
+
+  const request = await runSshJson({ target: ssh.value, command: `${remoteBin} auth request --json` });
+  const publicKey = typeof request?.publicKey === 'string' ? request.publicKey : '';
+  if (!publicKey) {
+    throw new Error('Remote auth request did not include "publicKey"');
+  }
+
+  await runLocalJson({
+    args: [...serverFlags.localArgs, 'auth', 'approve', '--public-key', publicKey, '--json'],
+  });
+
+  await runSshJson({
+    target: ssh.value,
+    command: `${remoteBin} auth wait --public-key ${safeBashSingleQuote(publicKey)} --json`,
+  });
+
+  if (service === 'user') {
+    const envParts = [];
+    if (serverFlags.serverUrl) envParts.push(`HAPPIER_DAEMON_SERVICE_SERVER_URL=${safeBashSingleQuote(serverFlags.serverUrl)}`);
+    if (serverFlags.webappUrl) envParts.push(`HAPPIER_DAEMON_SERVICE_WEBAPP_URL=${safeBashSingleQuote(serverFlags.webappUrl)}`);
+    if (serverFlags.publicServerUrl) envParts.push(`HAPPIER_DAEMON_SERVICE_PUBLIC_SERVER_URL=${safeBashSingleQuote(serverFlags.publicServerUrl)}`);
+    const envPrefix = envParts.length ? `${envParts.join(' ')} ` : '';
+
+    await runSsh({ target: ssh.value, command: `${envPrefix}${remoteBin} daemon service install` });
+    await runSsh({ target: ssh.value, command: `${envPrefix}${remoteBin} daemon service start` });
+  }
+
+  printResult({
+    json,
+    data: { ok: true, ssh: ssh.value, channel, service, publicKey },
+    text: json
+      ? null
+      : [
+          '✓ Remote daemon setup complete',
+          `- ssh: ${ssh.value}`,
+          `- channel: ${channel}`,
+          `- service: ${service}`,
+          `- publicKey: ${publicKey}`,
+        ].join('\n'),
+  });
+}
+
+async function main() {
+  const argvRaw = process.argv.slice(2);
+  if (argvRaw.length === 0 || wantsHelp(argvRaw)) {
+    printResult({ json: wantsJson(argvRaw), data: { usage: usageText() }, text: usageText() });
+    return;
+  }
+
+  const positionals = argvRaw.filter((a) => a && a !== '--' && !a.startsWith('-'));
+  const top = String(positionals[0] ?? '').trim();
+  const sub = String(positionals[1] ?? '').trim();
+
+  if (top === 'daemon' && sub === 'setup') {
+    await runRemoteDaemonSetup(argvRaw);
+    return;
+  }
+
+  printResult({
+    json: wantsJson(argvRaw),
+    data: { usage: usageText() },
+    text: usageText(),
+  });
+  process.exit(2);
+}
+
+main().catch((error) => {
+  const msg = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`${msg}\n`);
+  process.exit(1);
+});

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

@@ -0,0 +1,296 @@
+import assert from 'node:assert/strict';
+import { chmod, cp, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { homedir, tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+import nacl from 'tweetnacl';
+
+import { commandExists, extractBinaryFromArtifact, reserveLocalhostPort, run, waitForHealth } from './self_host_service_e2e_harness.mjs';
+
+const SELF_HOST_INSTALL_TIMEOUT_MS = 420_000;
+
+function currentTarget() {
+  if (process.platform === 'linux') {
+    if (process.arch === 'x64') return 'linux-x64';
+    if (process.arch === 'arm64') return 'linux-arm64';
+    return '';
+  }
+  if (process.platform === 'darwin') {
+    if (process.arch === 'x64') return 'darwin-x64';
+    if (process.arch === 'arm64') return 'darwin-arm64';
+    return '';
+  }
+  return '';
+}
+
+function deriveServerIdFromUrl(rawUrl) {
+  const normalized = String(rawUrl || '').trim().replace(/\/+$/, '');
+  let h = 2166136261;
+  for (let i = 0; i < normalized.length; i += 1) {
+    h ^= normalized.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return `env_${(h >>> 0).toString(16)}`;
+}
+
+async function writeCredentialsForServer({ homeDir, serverUrl, token }) {
+  const happyHomeDir = String(homeDir ?? '').trim();
+  assert.ok(happyHomeDir, 'homeDir is required');
+  const id = deriveServerIdFromUrl(serverUrl);
+  const scopedDir = join(happyHomeDir, 'servers', id);
+  await mkdir(scopedDir, { recursive: true });
+  await mkdir(happyHomeDir, { recursive: true });
+
+  const secret = Buffer.alloc(32, 7).toString('base64');
+  const payload = `${JSON.stringify({ token, secret }, null, 2)}\n`;
+
+  const legacyPath = join(happyHomeDir, 'access.key');
+  const scopedPath = join(scopedDir, 'access.key');
+  await writeFile(legacyPath, payload, { mode: 0o600 });
+  await writeFile(scopedPath, payload, { mode: 0o600 });
+  return { serverId: id };
+}
+
+async function createAuthToken(serverUrl) {
+  const keyPair = nacl.sign.keyPair();
+  const challenge = nacl.randomBytes(32);
+  const signature = nacl.sign.detached(challenge, keyPair.secretKey);
+  const encode64 = (bytes) => Buffer.from(bytes).toString('base64');
+
+  const url = new URL('/v1/auth', String(serverUrl));
+  if (url.hostname === 'localhost') url.hostname = '127.0.0.1';
+
+  const res = await fetch(url.toString(), {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      publicKey: encode64(keyPair.publicKey),
+      challenge: encode64(challenge),
+      signature: encode64(signature),
+    }),
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`[self-host-daemon] /v1/auth failed: ${res.status} ${res.statusText} ${text}`.trim());
+  }
+  const data = await res.json().catch(() => ({}));
+  const token = String(data?.token ?? '').trim();
+  if (!token) throw new Error('[self-host-daemon] /v1/auth response missing token');
+  return token;
+}
+
+function runAsRoot(cmd, args, { cwd, env, timeoutMs = 0, allowFail = false, stdio = 'pipe' } = {}) {
+  if (process.platform !== 'linux') {
+    return run(cmd, args, { label: 'self-host-daemon', cwd, env, timeoutMs, allowFail, stdio });
+  }
+  const mergedEnv = { ...process.env, ...(env ?? {}) };
+  if (typeof process.getuid === 'function' && process.getuid() === 0) {
+    return run(cmd, args, { label: 'self-host-daemon', cwd, env: mergedEnv, timeoutMs, allowFail, stdio });
+  }
+  if (!commandExists('sudo')) {
+    throw new Error('[self-host-daemon] sudo is required on linux system mode');
+  }
+  const envArgs = Object.entries(mergedEnv).map(([key, value]) => `${key}=${String(value ?? '')}`);
+  return run('sudo', ['-E', 'env', ...envArgs, cmd, ...args], {
+    label: 'self-host-daemon',
+    cwd,
+    env: process.env,
+    timeoutMs,
+    allowFail,
+    stdio,
+  });
+}
+
+test(
+  'self-host server + daemon integration suite works against installed runtime',
+  { timeout: 25 * 60_000 },
+  async (t) => {
+    const target = currentTarget();
+    if (!target) {
+      t.skip(`unsupported platform for daemon E2E: ${process.platform}-${process.arch}`);
+      return;
+    }
+    if (!commandExists('bun')) {
+      t.skip('bun is required to build compiled binaries');
+      return;
+    }
+    if (process.platform === 'linux' && !commandExists('systemctl')) {
+      t.skip('systemctl is required on linux self-host daemon E2E');
+      return;
+    }
+
+    const repoRoot = resolve(fileURLToPath(new URL('../../..', import.meta.url)));
+    const version = `0.0.0-daemon.${Date.now()}`;
+
+    run(
+      process.execPath,
+      [
+        'scripts/release/build-hstack-binaries.mjs',
+        '--channel=preview',
+        `--version=${version}`,
+        `--targets=${target}`,
+      ],
+      {
+        label: 'self-host-daemon',
+        cwd: repoRoot,
+        env: { ...process.env },
+        timeoutMs: 12 * 60_000,
+      }
+    );
+    run(
+      process.execPath,
+      [
+        'scripts/release/build-server-binaries.mjs',
+        '--channel=preview',
+        `--version=${version}`,
+        `--targets=${target}`,
+      ],
+      {
+        label: 'self-host-daemon',
+        cwd: repoRoot,
+        env: { ...process.env },
+        timeoutMs: 12 * 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-daemon', artifactPath: hstackArtifact, binaryName: process.platform === 'win32' ? 'hstack.exe' : 'hstack' });
+    const extractedServer = await extractBinaryFromArtifact({ label: 'self-host-daemon', artifactPath: serverArtifact, binaryName: process.platform === 'win32' ? 'happier-server.exe' : '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-daemon-'));
+    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');
+    const cliHomeDir = join(sandboxDir, 'cli-home');
+    await mkdir(binDir, { recursive: true });
+
+    const hstackPath = join(binDir, process.platform === 'win32' ? 'hstack.exe' : 'hstack');
+    await cp(extractedHstack.binaryPath, hstackPath);
+    await chmod(hstackPath, 0o755).catch(() => {});
+
+    const serviceName = `happier-server-e2e-${Date.now().toString(36).slice(-6)}`;
+    const serverPort = await reserveLocalhostPort();
+    const mode = process.platform === 'linux' ? 'system' : 'user';
+
+    const serverUrl = `http://127.0.0.1:${serverPort}`;
+    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',
+    };
+
+    let installSucceeded = false;
+    t.after(() => {
+      if (!installSucceeded) return;
+      runAsRoot(
+        hstackPath,
+        ['self-host', 'uninstall', '--channel=preview', `--mode=${mode}`, '--yes', '--purge-data', '--json'],
+        {
+          env: commonEnv,
+          allowFail: true,
+          timeoutMs: 180_000,
+          stdio: 'ignore',
+          cwd: sandboxDir,
+        }
+      );
+    });
+
+    const installResult = runAsRoot(
+      hstackPath,
+      ['self-host', 'install', '--channel=preview', `--mode=${mode}`, '--no-auto-update', '--non-interactive', '--without-cli', '--json'],
+      {
+        env: commonEnv,
+        timeoutMs: SELF_HOST_INSTALL_TIMEOUT_MS,
+        allowFail: true,
+        cwd: sandboxDir,
+      }
+    );
+    if ((installResult.status ?? 1) !== 0) {
+      const recovered = await waitForHealth(`${serverUrl}/v1/version`, 120_000);
+      if (!recovered) {
+        throw new Error(
+          [
+            '[self-host-daemon] self-host install failed and never became healthy',
+            `install status: ${String(installResult.status ?? 'null')}`,
+            `install stdout:\n${String(installResult.stdout ?? '').trim()}`,
+            `install stderr:\n${String(installResult.stderr ?? '').trim()}`,
+          ].join('\n\n')
+        );
+      }
+    }
+    installSucceeded = true;
+
+    const healthOk = await waitForHealth(`${serverUrl}/v1/version`, 120_000);
+    assert.equal(healthOk, true, 'self-host service health endpoint did not become ready');
+
+    const token = await createAuthToken(serverUrl);
+    const { serverId } = await writeCredentialsForServer({ homeDir: cliHomeDir, serverUrl, token });
+
+    const daemonEnv = {
+      ...process.env,
+      HAPPIER_HOME_DIR: cliHomeDir,
+      HAPPIER_ACTIVE_SERVER_ID: serverId,
+      HAPPIER_SERVER_URL: serverUrl,
+      HAPPIER_WEBAPP_URL: serverUrl,
+      HAPPIER_PUBLIC_SERVER_URL: serverUrl,
+      HAPPIER_NO_BROWSER_OPEN: '1',
+      HAPPIER_NONINTERACTIVE: '1',
+    };
+
+    // The daemon suite is unix-only (signals/ps); fail closed on unsupported.
+    if (process.platform === 'linux' || process.platform === 'darwin') {
+      const daemonRun = run(
+        'yarn',
+        ['--cwd', 'apps/cli', '-s', 'vitest', 'run', '--config', 'vitest.integration.config.ts', 'src/daemon/daemon.integration.test.ts'],
+        {
+          label: 'self-host-daemon',
+          cwd: repoRoot,
+          env: daemonEnv,
+          timeoutMs: 15 * 60_000,
+          allowFail: true,
+          stdio: 'inherit',
+        }
+      );
+      assert.equal(daemonRun.status, 0, 'daemon integration suite failed against self-host install');
+    } else {
+      t.skip(`daemon integration suite is unsupported on ${process.platform}`);
+      return;
+    }
+
+    runAsRoot(
+      hstackPath,
+      ['self-host', 'uninstall', '--channel=preview', `--mode=${mode}`, '--yes', '--purge-data', '--json'],
+      { env: commonEnv, timeoutMs: 180_000, cwd: sandboxDir }
+    );
+    installSucceeded = false;
+
+    const healthAfter = await waitForHealth(`${serverUrl}/v1/version`, 10_000);
+    assert.equal(healthAfter, false, 'server should not remain healthy after uninstall');
+  }
+);