@happier-dev/stack 0.1.0 → 0.2.0

package/scripts/self_host/install_companion_cli.mjs

@@ -0,0 +1,156 @@
+import { spawnSync } from 'node:child_process';
+import { mkdir, mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+import {
+  getFirstPartyComponentCatalogEntry,
+  installVersionedPayload,
+  resolveFirstPartyComponentPublicReleaseVariant,
+} from '@happier-dev/cli-common/firstPartyRuntime';
+import { resolveReleaseAssetBundle } from '@happier-dev/release-runtime/assets';
+import { planArchiveExtraction } from '@happier-dev/release-runtime/extractPlan';
+import { fetchGitHubReleaseByTag } from '@happier-dev/release-runtime/github';
+import { DEFAULT_MINISIGN_PUBLIC_KEY } from '@happier-dev/release-runtime/minisign';
+import { downloadVerifiedReleaseAssetBundle } from '@happier-dev/release-runtime/verifiedDownload';
+
+import { findExtractedExecutableByName } from './findExtractedExecutableByName.mjs';
+
+function commandExists(name) {
+  if (process.platform === 'win32') {
+    return (spawnSync('where', [name], { stdio: 'ignore' }).status ?? 1) === 0;
+  }
+  return (spawnSync('sh', ['-lc', `command -v ${name} >/dev/null 2>&1`], { stdio: 'ignore' }).status ?? 1) === 0;
+}
+
+function normalizeArch() {
+  const arch = process.arch === 'x64' ? 'x64' : process.arch === 'arm64' ? 'arm64' : '';
+  if (!arch) {
+    throw new Error(`[self-host] unsupported architecture: ${process.arch}`);
+  }
+  return arch;
+}
+
+function normalizeOs(platform = process.platform) {
+  const p = String(platform ?? '').trim() || process.platform;
+  if (p === 'linux') return 'linux';
+  if (p === 'darwin') return 'darwin';
+  if (p === 'win32') return 'windows';
+  throw new Error(`[self-host] unsupported platform: ${p}`);
+}
+
+function resolveMinisignPublicKeyText(env = process.env) {
+  const inline = String(env?.HAPPIER_MINISIGN_PUBKEY ?? '').trim();
+  return inline || DEFAULT_MINISIGN_PUBLIC_KEY;
+}
+
+function runCheckedCommand(command, args, context) {
+  const result = spawnSync(command, args, { stdio: 'ignore', encoding: 'utf-8' });
+  if ((result.status ?? 1) !== 0) {
+    throw new Error(
+      `[self-host] ${context} failed (${command} ${args.join(' ')}): ${String(result.stderr ?? result.stdout ?? '').trim()}`,
+    );
+  }
+}
+
+export async function installCompanionCliFromBundle({
+  bundle,
+  channel = 'stable',
+  processEnv = process.env,
+  pubkeyFile = resolveMinisignPublicKeyText(processEnv),
+  userAgent = 'happier-self-host-installer',
+}) {
+  const component = getFirstPartyComponentCatalogEntry('happier-cli');
+  const binaryName = process.platform === 'win32' ? `${component.executableBaseName}.exe` : component.executableBaseName;
+  const resolvedBundle = bundle;
+  if (!resolvedBundle?.archive?.url || !resolvedBundle?.archive?.name) {
+    throw new Error('[self-host] invalid companion CLI release bundle (missing archive)');
+  }
+  if (!resolvedBundle?.checksums?.url || !resolvedBundle?.checksumsSig?.url) {
+    throw new Error('[self-host] invalid companion CLI release bundle (missing checksums assets)');
+  }
+
+  const tempDir = await mkdtemp(join(tmpdir(), 'happier-self-host-companion-cli-'));
+  try {
+    const downloaded = await downloadVerifiedReleaseAssetBundle({
+      bundle: resolvedBundle,
+      destDir: tempDir,
+      pubkeyFile,
+      userAgent,
+    });
+    const extractDir = join(tempDir, 'extract');
+    await mkdir(extractDir, { recursive: true });
+    const plan = planArchiveExtraction({
+      archiveName: downloaded.archiveName,
+      archivePath: downloaded.archivePath,
+      destDir: extractDir,
+      os: normalizeOs(process.platform),
+    });
+    if (!commandExists(plan.requiredCommand)) {
+      throw new Error(`[self-host] ${plan.requiredCommand} is required to extract companion CLI artifacts`);
+    }
+    runCheckedCommand(plan.command.cmd, plan.command.args, 'extracting companion CLI release bundle');
+
+    const extractedBinaryPath = await findExtractedExecutableByName(extractDir, binaryName);
+    if (!extractedBinaryPath) {
+      throw new Error('[self-host] failed to locate extracted companion CLI binary');
+    }
+
+    const version = downloaded.version || String(resolvedBundle?.version ?? '').trim() || `${Date.now()}`;
+    await installVersionedPayload({
+      componentId: 'happier-cli',
+      versionId: version,
+      payloadRoot: dirname(extractedBinaryPath),
+      channel,
+      processEnv,
+    });
+
+    return {
+      installed: true,
+      version,
+      source: resolvedBundle.archive.url,
+      reason: 'installed',
+    };
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}
+
+export async function maybeInstallCompanionCli({
+  channel,
+  githubRepo,
+  withCli,
+  processEnv = process.env,
+}) {
+  if (!withCli) return { installed: false, reason: 'disabled' };
+  const componentVariant = resolveFirstPartyComponentPublicReleaseVariant({
+    componentId: 'happier-cli',
+    channel,
+  });
+  if (componentVariant.installShims.some((shimName) => commandExists(shimName))) {
+    return { installed: false, reason: 'already-installed' };
+  }
+
+  const component = getFirstPartyComponentCatalogEntry('happier-cli');
+  const tag = componentVariant.releaseTag;
+  const release = await fetchGitHubReleaseByTag({
+    githubRepo,
+    tag,
+    userAgent: 'happier-self-host-installer',
+    githubToken: String(processEnv.GITHUB_TOKEN ?? processEnv.GH_TOKEN ?? ''),
+  });
+  const bundle = resolveReleaseAssetBundle({
+    assets: release?.assets,
+    product: component.releaseProductName,
+    os: normalizeOs(process.platform),
+    arch: normalizeArch(),
+  });
+
+  return installCompanionCliFromBundle({
+    bundle,
+    channel,
+    processEnv,
+    pubkeyFile: resolveMinisignPublicKeyText(processEnv),
+    userAgent: 'happier-self-host-installer',
+  });
+}

package/scripts/self_host/install_companion_cli.test.mjs

@@ -0,0 +1,119 @@
+import assert from 'node:assert/strict';
+import { createHash, generateKeyPairSync, sign } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import test from 'node:test';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+import { installCompanionCliFromBundle } from './install_companion_cli.mjs';
+
+function b64(buf) {
+  return Buffer.from(buf).toString('base64');
+}
+
+function base64UrlToBuffer(value) {
+  const s = String(value ?? '')
+    .replace(/-/g, '+')
+    .replace(/_/g, '/')
+    .padEnd(Math.ceil(String(value ?? '').length / 4) * 4, '=');
+  return Buffer.from(s, 'base64');
+}
+
+function createMinisignKeyPair() {
+  const { publicKey, privateKey } = generateKeyPairSync('ed25519');
+  const jwk = publicKey.export({ format: 'jwk' });
+  const rawPublicKey = base64UrlToBuffer(jwk.x);
+  const keyId = Buffer.from('0123456789abcdef', 'hex');
+  const publicKeyBytes = Buffer.concat([Buffer.from('Ed'), keyId, rawPublicKey]);
+  const pubkeyFile = `untrusted comment: minisign public key\n${b64(publicKeyBytes)}\n`;
+  return { pubkeyFile, keyId, privateKey };
+}
+
+function signMinisignMessage({ message, keyId, privateKey }) {
+  const signature = sign(null, message, privateKey);
+  const sigLineBytes = Buffer.concat([Buffer.from('Ed'), keyId, signature]);
+  const trustedComment = 'trusted comment: test';
+  const trustedSuffix = Buffer.from(trustedComment.slice('trusted comment: '.length), 'utf-8');
+  const globalSignature = sign(null, Buffer.concat([signature, trustedSuffix]), privateKey);
+  return [
+    'untrusted comment: signature from happier stack test',
+    b64(sigLineBytes),
+    trustedComment,
+    b64(globalSignature),
+    '',
+  ].join('\n');
+}
+
+function sha256Hex(bytes) {
+  return createHash('sha256').update(bytes).digest('hex');
+}
+
+test('installCompanionCliFromBundle promotes the publicdev CLI payload with shared installer logic', async (t) => {
+  if (process.platform === 'win32') {
+    t.skip('tar-based bundle test does not run on windows');
+    return;
+  }
+  if (spawnSync('bash', ['-lc', 'command -v tar >/dev/null 2>&1'], { stdio: 'ignore' }).status !== 0) {
+    t.skip('tar is required for bundle installation test');
+    return;
+  }
+
+  const tmp = await mkdtemp(join(tmpdir(), 'happier-self-host-companion-cli-'));
+  t.after(async () => {
+    await rm(tmp, { recursive: true, force: true });
+  });
+
+  const staging = join(tmp, 'staging');
+  const rootName = 'happier-v1.2.3-dev.1-darwin-arm64';
+  const rootDir = join(staging, rootName);
+  await mkdir(join(rootDir, 'package-dist'), { recursive: true });
+  await writeFile(join(rootDir, 'package-dist', 'index.mjs'), 'console.log("ok");\n', 'utf-8');
+  const binaryPath = join(rootDir, 'happier');
+  await writeFile(binaryPath, '#!/bin/sh\necho happier\n', 'utf-8');
+  spawnSync('bash', ['-lc', `chmod +x "${binaryPath.replaceAll('"', '\\"')}"`], { stdio: 'ignore' });
+
+  const archiveName = `${rootName}.tar.gz`;
+  const archivePath = join(tmp, archiveName);
+  const tar = spawnSync('tar', ['-czf', archivePath, '-C', staging, rootName], { encoding: 'utf-8' });
+  assert.equal(tar.status, 0, tar.stderr || tar.stdout);
+
+  const archiveBytes = await readFile(archivePath);
+  const checksumsText = `${sha256Hex(archiveBytes)} ${archiveName}\n`;
+  const { pubkeyFile, keyId, privateKey } = createMinisignKeyPair();
+  const sigFile = signMinisignMessage({
+    message: Buffer.from(checksumsText, 'utf-8'),
+    keyId,
+    privateKey,
+  });
+
+  const bundle = {
+    version: '1.2.3-dev.1',
+    archive: { name: archiveName, url: `data:application/octet-stream;base64,${archiveBytes.toString('base64')}` },
+    checksums: { name: 'checksums-happier-v1.2.3-dev.1.txt', url: `data:text/plain,${encodeURIComponent(checksumsText)}` },
+    checksumsSig: { name: 'checksums-happier-v1.2.3-dev.1.txt.minisig', url: `data:text/plain,${encodeURIComponent(sigFile)}` },
+  };
+
+  const homeDir = join(tmp, 'home');
+  const result = await installCompanionCliFromBundle({
+    bundle,
+    channel: 'publicdev',
+    processEnv: {
+      ...process.env,
+      HAPPIER_HOME_DIR: homeDir,
+    },
+    pubkeyFile,
+  });
+
+  assert.equal(result.installed, true);
+  assert.equal(result.version, '1.2.3-dev.1');
+  assert.equal(existsSync(join(homeDir, 'cli-dev', 'current', 'package-dist', 'index.mjs')), true);
+  assert.equal(existsSync(join(homeDir, 'cli-dev', 'previous')), false);
+  const installedEntrypoint = await readFile(join(homeDir, 'cli-dev', 'current', 'package-dist', 'index.mjs'), 'utf-8');
+  assert.match(installedEntrypoint, /console\.log\("ok"\)/);
+  assert.equal(existsSync(join(homeDir, 'bin', 'hdev')), true);
+  const resolvedCurrentBinary = join(homeDir, 'cli-dev', 'current', 'happier');
+  assert.equal(existsSync(resolvedCurrentBinary), true);
+  assert.equal(existsSync(dirname(join(homeDir, 'cli-dev', 'versions', '1.2.3-dev.1'))), true);
+});

package/scripts/self_host/version_retention.mjs

@@ -0,0 +1,69 @@
+import { readdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { resolveRetainedVersionIds } from '@happier-dev/cli-common/firstPartyRuntime';
+import { compareVersions } from '@happier-dev/cli-common/update';
+
+function trimVersionPrefix(entryName, entryPrefix) {
+  const normalizedEntryName = String(entryName ?? '').trim();
+  const normalizedPrefix = String(entryPrefix ?? '').trim();
+  if (!normalizedEntryName || !normalizedPrefix || !normalizedEntryName.startsWith(normalizedPrefix)) {
+    return '';
+  }
+  return normalizedEntryName.slice(normalizedPrefix.length).trim();
+}
+
+function compareSelfHostVersionIds(left, right) {
+  const leftText = String(left ?? '').trim();
+  const rightText = String(right ?? '').trim();
+  const leftLocal = /^local-(\d+)$/.exec(leftText);
+  const rightLocal = /^local-(\d+)$/.exec(rightText);
+  if (leftLocal && rightLocal) {
+    const leftValue = Number(leftLocal[1]);
+    const rightValue = Number(rightLocal[1]);
+    if (Number.isFinite(leftValue) && Number.isFinite(rightValue) && leftValue !== rightValue) {
+      return leftValue > rightValue ? 1 : -1;
+    }
+  }
+  return compareVersions(leftText, rightText);
+}
+
+export async function listVersionedDirectoryIdsNewestFirst({ versionsDir, entryPrefix }) {
+  const entries = await readdir(versionsDir, { withFileTypes: true }).catch(() => []);
+
+  return entries
+    .filter((entry) => entry.isDirectory() || entry.isFile())
+    .map((entry) => trimVersionPrefix(entry.name, entryPrefix))
+    .filter(Boolean)
+    .sort((left, right) => compareSelfHostVersionIds(right, left));
+}
+
+export async function pruneVersionedDirectories({
+  versionsDir,
+  entryPrefix,
+  currentVersionId,
+  previousVersionId = null,
+  retainCount = 2,
+}) {
+  const orderedVersionIdsNewestFirst = await listVersionedDirectoryIdsNewestFirst({
+    versionsDir,
+    entryPrefix,
+  });
+  const { keep, prune } = resolveRetainedVersionIds({
+    orderedVersionIdsNewestFirst,
+    currentVersionId,
+    previousVersionId,
+    retainCount,
+  });
+
+  await Promise.all(
+    prune.map(async (versionId) => {
+      await rm(join(versionsDir, `${entryPrefix}${versionId}`), { recursive: true, force: true });
+    }),
+  );
+
+  return {
+    keptVersionIds: keep,
+    prunedVersionIds: prune,
+  };
+}

package/scripts/self_host/version_retention.test.mjs

@@ -0,0 +1,100 @@
+import assert from 'node:assert/strict';
+import { existsSync } from 'node:fs';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import test from 'node:test';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { listVersionedDirectoryIdsNewestFirst, pruneVersionedDirectories } from './version_retention.mjs';
+
+test('pruneVersionedDirectories keeps current and previous server versions', async (t) => {
+  const root = await mkdtemp(join(tmpdir(), 'happier-self-host-version-retention-'));
+  t.after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  const versionsDir = join(root, 'versions');
+  await mkdir(versionsDir, { recursive: true });
+  for (const version of ['1.2.1', '1.2.2', '1.2.3']) {
+    await writeFile(join(versionsDir, `happier-server-${version}`), version, 'utf-8');
+  }
+
+  const ordered = await listVersionedDirectoryIdsNewestFirst({
+    versionsDir,
+    entryPrefix: 'happier-server-',
+  });
+  assert.deepEqual(ordered, ['1.2.3', '1.2.2', '1.2.1']);
+
+  const result = await pruneVersionedDirectories({
+    versionsDir,
+    entryPrefix: 'happier-server-',
+    currentVersionId: '1.2.3',
+    previousVersionId: '1.2.2',
+  });
+
+  assert.deepEqual(result.keptVersionIds, ['1.2.3', '1.2.2']);
+  assert.deepEqual(result.prunedVersionIds, ['1.2.1']);
+  assert.equal(existsSync(join(versionsDir, 'happier-server-1.2.1')), false);
+  assert.equal(existsSync(join(versionsDir, 'happier-server-1.2.2')), true);
+  assert.equal(existsSync(join(versionsDir, 'happier-server-1.2.3')), true);
+});
+
+test('pruneVersionedDirectories sorts preview ui web versions newest first and keeps two newest by default', async (t) => {
+  const root = await mkdtemp(join(tmpdir(), 'happier-self-host-ui-version-retention-'));
+  t.after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  const versionsDir = join(root, 'versions');
+  await mkdir(versionsDir, { recursive: true });
+  for (const version of ['1.2.3-preview.1', '1.2.3-preview.3', '1.2.3-preview.2']) {
+    const dir = join(versionsDir, `happier-ui-web-${version}`);
+    await mkdir(dir, { recursive: true });
+  }
+
+  const ordered = await listVersionedDirectoryIdsNewestFirst({
+    versionsDir,
+    entryPrefix: 'happier-ui-web-',
+  });
+  assert.deepEqual(ordered, ['1.2.3-preview.3', '1.2.3-preview.2', '1.2.3-preview.1']);
+
+  const result = await pruneVersionedDirectories({
+    versionsDir,
+    entryPrefix: 'happier-ui-web-',
+    currentVersionId: '1.2.3-preview.3',
+  });
+
+  assert.deepEqual(result.keptVersionIds, ['1.2.3-preview.3', '1.2.3-preview.2']);
+  assert.deepEqual(result.prunedVersionIds, ['1.2.3-preview.1']);
+  assert.equal(existsSync(join(versionsDir, 'happier-ui-web-1.2.3-preview.1')), false);
+});
+
+test('pruneVersionedDirectories sorts local timestamp versions numerically and keeps the newest two', async (t) => {
+  const root = await mkdtemp(join(tmpdir(), 'happier-self-host-local-version-retention-'));
+  t.after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  const versionsDir = join(root, 'versions');
+  await mkdir(versionsDir, { recursive: true });
+  for (const version of ['local-500', 'local-2000', 'local-1000']) {
+    await writeFile(join(versionsDir, `happier-server-${version}`), version, 'utf-8');
+  }
+
+  const ordered = await listVersionedDirectoryIdsNewestFirst({
+    versionsDir,
+    entryPrefix: 'happier-server-',
+  });
+  assert.deepEqual(ordered, ['local-2000', 'local-1000', 'local-500']);
+
+  const result = await pruneVersionedDirectories({
+    versionsDir,
+    entryPrefix: 'happier-server-',
+    currentVersionId: 'local-2000',
+    previousVersionId: 'local-1000',
+  });
+
+  assert.deepEqual(result.keptVersionIds, ['local-2000', 'local-1000']);
+  assert.deepEqual(result.prunedVersionIds, ['local-500']);
+  assert.equal(existsSync(join(versionsDir, 'happier-server-local-500')), false);
+});

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

@@ -128,18 +128,40 @@ test(
     const serverErrLog = join(logDir, 'server.err.log');
 
     let installSucceeded = false;
-    t.after(() => {
-      run(
-        hstackPath,
-        ['self-host', 'uninstall', '--channel=preview', '--mode=user', '--yes', '--purge-data', '--json'],
-        {
-          env: commonEnv,
-          allowFail: true,
-          timeoutMs: 120_000,
-          stdio: 'ignore',
-          cwd: sandboxDir,
+    t.after(async () => {
+      try {
+        run(
+          hstackPath,
+          ['self-host', 'uninstall', '--channel=preview', '--mode=user', '--yes', '--purge-data', '--json'],
+          {
+            env: commonEnv,
+            allowFail: true,
+            timeoutMs: 120_000,
+            stdio: 'ignore',
+            cwd: sandboxDir,
+          }
+        );
+      } catch {
+        // ignore
+      }
+
+      // Extra best-effort cleanup: if the uninstall path fails early (or the test aborts mid-install),
+      // ensure the LaunchAgent is removed so we don't leave behind Background Items / launchd jobs.
+      try {
+        const home = String(commonEnv.HOME ?? '').trim();
+        if (!home) return;
+        const uid = typeof process.getuid === 'function' ? process.getuid() : null;
+        const plistPath = join(home, 'Library', 'LaunchAgents', `${serviceName}.plist`);
+
+        run('launchctl', ['remove', serviceName], { allowFail: true, timeoutMs: 20_000, stdio: 'ignore' });
+        if (uid != null) {
+          run('launchctl', ['bootout', `gui/${uid}`, plistPath], { allowFail: true, timeoutMs: 20_000, stdio: 'ignore' });
         }
-      );
+        run('launchctl', ['unload', '-w', plistPath], { allowFail: true, timeoutMs: 20_000, stdio: 'ignore' });
+        await rm(plistPath, { force: true });
+      } catch {
+        // best-effort only
+      }
     });
 
     const installResult = run(