@happier-dev/stack 0.1.0-preview.17.1 → 0.1.0-preview.21.1

package/scripts/providers_cmd.mjs

@@ -0,0 +1,262 @@
+import './utils/env/env.mjs';
+
+import { parseArgs } from './utils/cli/args.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
+import { createStepPrinter, runCommandLogged } from './utils/cli/progress.mjs';
+import { AGENT_IDS, getProviderCliInstallSpec } from '@happier-dev/agents';
+import { installProviderCli, planProviderCliInstall, resolvePlatformFromNodePlatform } from '@happier-dev/cli-common/providers';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+function usageText() {
+  return [
+    '[providers] usage:',
+    '  hstack providers list [--json]',
+    '  hstack providers install --providers=<id1,id2> [--dry-run] [--force] [--json]',
+    '  hstack providers install <id1> <id2> [--dry-run] [--force] [--json]',
+    '',
+    'notes:',
+    '  - Provider CLIs are external binaries used by Happier backends (claude/codex/gemini/etc).',
+    '  - This command installs provider CLIs (best-effort). Some providers require manual installation.',
+    '  - Claude install uses the upstream native installer by default (not npm).',
+    '  - Use --force to re-run the installer even if the binary is already present on PATH.',
+  ].join('\n');
+}
+
+function splitProviders(raw) {
+  const v = String(raw ?? '').trim();
+  if (!v) return [];
+  return v
+    .split(',')
+    .map((s) => s.trim().toLowerCase())
+    .filter(Boolean);
+}
+
+function resolvePlatform() {
+  return resolvePlatformFromNodePlatform(process.platform) ?? 'unsupported';
+}
+
+function commandExists(cmd, env) {
+  const name = String(cmd ?? '').trim();
+  if (!name) return false;
+
+  const pathEnv = env?.PATH ?? process.env.PATH;
+  if (process.platform === 'win32') {
+    const res = spawnSync('where', [name], { stdio: 'ignore', env: { ...process.env, ...(env ?? {}), PATH: pathEnv } });
+    return (res.status ?? 1) === 0;
+  }
+  const res = spawnSync('sh', ['-lc', `command -v ${name} >/dev/null 2>&1`], { stdio: 'ignore', env: { ...process.env, ...(env ?? {}), PATH: pathEnv } });
+  return (res.status ?? 1) === 0;
+}
+
+function resolveProviderInstallLogPath(providerId) {
+  const base = join(tmpdir(), 'happier-provider-installs');
+  mkdirSync(base, { recursive: true });
+  return join(base, `install-provider-${providerId}-${Date.now()}.log`);
+}
+
+function planForProvider(providerId) {
+  const platform = resolvePlatform();
+  if (platform === 'unsupported') {
+    return { ok: false, provider: providerId, error: 'Unsupported platform' };
+  }
+  const planned = planProviderCliInstall({ providerId, platform });
+  if (!planned.ok) {
+    return { ok: false, provider: providerId, error: planned.errorMessage };
+  }
+  return { ok: true, provider: providerId, commands: planned.plan.commands };
+}
+
+async function cmdList({ argv }) {
+  const { flags } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+  const platform = resolvePlatform();
+  const rows = AGENT_IDS.map((id) => {
+    const spec = getProviderCliInstallSpec(id);
+    const planned = planForProvider(id);
+    return {
+      id: spec.id,
+      title: spec.title,
+      binaries: spec.binaries,
+      autoInstall: planned.ok,
+      note: planned.ok ? null : planned.error,
+      platform,
+    };
+  });
+
+  printResult({
+    json,
+    data: { ok: true, platform, providers: rows },
+    text: json
+      ? null
+      : rows
+          .map((r) => `${r.autoInstall ? '✓' : '-'} ${r.id}${r.title ? `  (${r.title})` : ''}${r.note ? ` — ${r.note}` : ''}`)
+          .join('\n'),
+  });
+}
+
+async function cmdInstall({ argv }) {
+  const { flags, kv } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+  const dryRun = flags.has('--dry-run') || flags.has('--plan');
+  const force = flags.has('--force') || flags.has('--reinstall');
+  const skipIfInstalled = !force;
+
+  const positionals = argv.filter((a) => a && a !== '--' && !a.startsWith('-'));
+  const inputFromFlag = kv.get('--providers') ?? '';
+  const inputFromPositional = positionals;
+
+  const wanted = [
+    ...splitProviders(inputFromFlag),
+    ...inputFromPositional.flatMap((s) => splitProviders(String(s).trim().toLowerCase())),
+  ];
+
+  if (wanted.length === 0) {
+    throw new Error('[providers] missing providers. Use --providers=claude,codex or pass ids as positionals.');
+  }
+
+  const resolved = wanted.map((id) => {
+    if (!AGENT_IDS.includes(id)) {
+      const e = new Error(`[providers] unknown provider: ${id}`);
+      e.code = 'EUNKNOWN_PROVIDER';
+      throw e;
+    }
+    return id;
+  });
+
+  const platform = resolvePlatform();
+  if (platform === 'unsupported') {
+    throw new Error('[providers] unsupported platform');
+  }
+
+  // In json mode, preserve the existing structured behavior (no progress output).
+  if (json) {
+    const results = resolved.map((providerId) =>
+      installProviderCli({ providerId, platform, dryRun, skipIfInstalled, env: process.env }),
+    );
+    const failures = results.filter((r) => !r.ok);
+    if (failures.length > 0) {
+      const first = failures[0];
+      const extra = first.logPath ? `\nlog: ${first.logPath}` : '';
+      throw new Error(`[providers] install failed: ${first.errorMessage}${extra}`.trim());
+    }
+
+    const plan = results.map((r) => (r.ok ? r.plan : null)).filter(Boolean);
+
+    printResult({
+      json,
+      data: {
+        ok: true,
+        providers: resolved,
+        dryRun,
+        skipIfInstalled,
+        plan,
+        results: results.map((r) => (r.ok ? { ok: true, providerId: r.plan.providerId, alreadyInstalled: r.alreadyInstalled, logPath: r.logPath } : r)),
+      },
+      text: null,
+    });
+    return;
+  }
+
+  // Human-friendly progress output (TTY spinner when interactive; simple lines otherwise).
+  const steps = createStepPrinter({ enabled: true });
+  const results = [];
+  for (const providerId of resolved) {
+    const spec = getProviderCliInstallSpec(providerId);
+    const planned = planProviderCliInstall({ providerId, platform });
+    if (!planned.ok) {
+      throw new Error(`[providers] install failed: ${planned.errorMessage}`);
+    }
+
+    const label = `Installing ${spec.title || `${providerId} CLI`}`;
+    const binariesPresent = skipIfInstalled && spec.binaries.every((b) => commandExists(b, process.env));
+    if (binariesPresent) {
+      steps.info(`- [✓] ${label} (already installed)`);
+      results.push({ ok: true, providerId, alreadyInstalled: true, logPath: null, plan: planned.plan });
+      continue;
+    }
+
+    steps.start(label);
+    if (dryRun) {
+      steps.stop('✓', `${label} (dry-run)`);
+      results.push({ ok: true, providerId, alreadyInstalled: false, logPath: null, plan: planned.plan });
+      continue;
+    }
+
+    const logPath = resolveProviderInstallLogPath(providerId);
+    writeFileSync(
+      logPath,
+      [`# providerId: ${providerId}`, `# platform: ${platform}`, ''].join('\n'),
+      'utf8',
+    );
+
+    try {
+      for (const c of planned.plan.commands) {
+        // eslint-disable-next-line no-await-in-loop
+        await runCommandLogged({
+          label,
+          cmd: c.cmd,
+          args: c.args,
+          cwd: process.cwd(),
+          env: process.env,
+          logPath,
+          showSteps: false,
+          quiet: true,
+        });
+      }
+    } catch (e) {
+      steps.stop('x', label);
+      const message = e instanceof Error ? e.message : String(e);
+      throw new Error(`[providers] install failed: ${message}\nlog: ${logPath}`);
+    }
+
+    steps.stop('✓', label);
+    results.push({ ok: true, providerId, alreadyInstalled: false, logPath, plan: planned.plan });
+  }
+
+  printResult({
+    json,
+    data: {
+      ok: true,
+      providers: resolved,
+      dryRun,
+      skipIfInstalled,
+      plan: results.map((r) => r.plan),
+      results: results.map((r) => ({ ok: true, providerId: r.providerId, alreadyInstalled: r.alreadyInstalled, logPath: r.logPath })),
+    },
+    text: json ? null : `✓ providers installed: ${resolved.join(', ')}`,
+  });
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const { flags } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+
+  if (argv.length === 0 || wantsHelp(argv, { flags })) {
+    printResult({ json, data: { usage: usageText() }, text: usageText() });
+    return;
+  }
+
+  const positionals = argv.filter((a) => a && a !== '--' && !a.startsWith('-'));
+  const sub = String(positionals[0] ?? '').trim();
+  if (sub === 'list') {
+    await cmdList({ argv: argv.slice(1) });
+    return;
+  }
+  if (sub === 'install') {
+    await cmdInstall({ argv: argv.slice(1) });
+    return;
+  }
+
+  printResult({ json, 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/release_binary_smoke.integration.test.mjs

@@ -27,23 +27,23 @@ function commandExists(cmd) {
   return spawnSync('bash', ['-lc', `command -v ${cmd} >/dev/null 2>&1`], { stdio: 'ignore' }).status === 0;
 }
 
-function runWithHardTimeout({ cmd, args, cwd, env, encoding, maxBuffer, timeoutMs }) {
-  if (commandExists('timeout')) {
-    const seconds = Math.max(1, Math.ceil(timeoutMs / 1000));
-    return spawnSync('timeout', ['--signal=KILL', '--kill-after=30s', `${seconds}s`, cmd, ...args], {
-      cwd,
-      encoding,
-      env,
-      maxBuffer,
+function runWithHardTimeout(command, args, options) {
+  const timeoutMs = Number(options.timeout ?? 0);
+  if (process.platform === 'linux' && commandExists('timeout') && timeoutMs > 0) {
+    const timeoutSeconds = Math.max(1, Math.ceil(timeoutMs / 1000));
+    return spawnSync('timeout', ['--signal=KILL', '--kill-after=30s', `${timeoutSeconds}s`, command, ...args], {
+      ...options,
+      timeout: undefined,
     });
   }
-  return spawnSync(cmd, args, {
-    cwd,
-    encoding,
-    env,
-    maxBuffer,
-    timeout: timeoutMs,
-  });
+  return spawnSync(command, args, options);
+}
+
+function didCommandTimeout(result) {
+  if (result?.error?.code === 'ETIMEDOUT') return true;
+  if (result?.status === 124 || result?.status === 137) return true;
+  if (result?.signal === 'SIGKILL') return true;
+  return false;
 }
 
 function currentTarget() {
@@ -84,20 +84,25 @@ test('compiled happier and server binaries execute from isolated cwd', async (t)
   const repoRoot = resolve(fileURLToPath(new URL('../../..', import.meta.url)));
   const version = `0.0.0-smoke.${Date.now()}`;
 
-  const buildCli = runWithHardTimeout({
-    cmd: process.execPath,
-    args: [
+  const buildCli = runWithHardTimeout(
+    process.execPath,
+    [
       'scripts/release/build-cli-binaries.mjs',
       '--channel=preview',
       `--version=${version}`,
       `--targets=${target}`,
     ],
-    cwd: repoRoot,
-    encoding: 'utf-8',
-    env: { ...process.env },
-    maxBuffer: 50 * 1024 * 1024,
-    timeoutMs: 15 * 60 * 1000,
-  });
+    {
+      cwd: repoRoot,
+      encoding: 'utf-8',
+      env: { ...process.env },
+      // `inherit` makes it easier to read interactively, but on CI failures we need the full output.
+      // Increase buffer because build logs can be large.
+      maxBuffer: 50 * 1024 * 1024,
+      // If this ever hangs on CI, fail with a clear timeout rather than blocking the entire suite.
+      timeout: 15 * 60 * 1000,
+    }
+  );
   assert.equal(buildCli.status, 0, formatSpawnSyncResult(buildCli));
 
   const cliArtifactPath = join(repoRoot, 'dist', 'release-assets', 'cli', `happier-v${version}-${target}.tar.gz`);
@@ -105,13 +110,13 @@ test('compiled happier and server binaries execute from isolated cwd', async (t)
   t.after(() => {
     spawnSync('bash', ['-lc', `rm -rf "${cliExtract.extractDir.replaceAll('"', '\\"')}"`], { stdio: 'ignore' });
   });
-  const cliVersion = spawnSync(cliExtract.binaryPath, ['--version'], {
+  const cliVersion = runWithHardTimeout(cliExtract.binaryPath, ['--version'], {
     cwd: '/tmp',
     encoding: 'utf-8',
     env: { ...process.env, HAPPIER_NONINTERACTIVE: '1' },
     timeout: 7000,
   });
-  const cliTimedOut = cliVersion.error && cliVersion.error.code === 'ETIMEDOUT';
+  const cliTimedOut = didCommandTimeout(cliVersion);
   const cliExited = (cliVersion.status ?? 1) === 0;
   assert.ok(cliTimedOut || cliExited, cliVersion.stderr || cliVersion.stdout);
   const versionText = `${cliVersion.stdout || ''}${cliVersion.stderr || ''}`.trim();
@@ -121,20 +126,23 @@ test('compiled happier and server binaries execute from isolated cwd', async (t)
   );
 
   if (isLinuxTarget(target)) {
-    const buildServer = runWithHardTimeout({
-      cmd: process.execPath,
-      args: [
+    const buildServer = runWithHardTimeout(
+      process.execPath,
+      [
         'scripts/release/build-server-binaries.mjs',
         '--channel=preview',
         `--version=${version}`,
         `--targets=${target}`,
       ],
-      cwd: repoRoot,
-      encoding: 'utf-8',
-      env: { ...process.env },
-      maxBuffer: 50 * 1024 * 1024,
-      timeoutMs: 15 * 60 * 1000,
-    });
+      {
+        cwd: repoRoot,
+        encoding: 'utf-8',
+        env: { ...process.env },
+        maxBuffer: 50 * 1024 * 1024,
+        // If this ever hangs on CI, fail with a clear timeout rather than blocking the entire suite.
+        timeout: 15 * 60 * 1000,
+      }
+    );
     assert.equal(buildServer.status, 0, formatSpawnSyncResult(buildServer));
 
     const serverArtifactPath = join(repoRoot, 'dist', 'release-assets', 'server', `happier-server-v${version}-${target}.tar.gz`);
@@ -146,7 +154,7 @@ test('compiled happier and server binaries execute from isolated cwd', async (t)
     t.after(() => {
       spawnSync('bash', ['-lc', `rm -rf "${serverDataDir.replaceAll('"', '\\"')}"`], { stdio: 'ignore' });
     });
-    const serverBoot = spawnSync(serverExtract.binaryPath, [], {
+    const serverBoot = runWithHardTimeout(serverExtract.binaryPath, [], {
       cwd: '/tmp',
       encoding: 'utf-8',
       env: {
@@ -161,7 +169,7 @@ test('compiled happier and server binaries execute from isolated cwd', async (t)
       },
       timeout: 7000,
     });
-    const timedOut = serverBoot.error && serverBoot.error.code === 'ETIMEDOUT';
+    const timedOut = didCommandTimeout(serverBoot);
     const cleanExit = (serverBoot.status ?? 1) === 0;
     const serverOutput = `${serverBoot.stderr || ''}\n${serverBoot.stdout || ''}`;
     assert.ok(timedOut || cleanExit, serverOutput);