@happier-dev/stack 0.2.1-preview.1775586714.26562 → 0.2.11

package/scripts/stack_daemon_cmd.integration.test.mjs

@@ -2,6 +2,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { existsSync } from 'node:fs';
 import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { createServer } from 'node:http';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { resolveStackCredentialPaths } from './utils/auth/credentials_paths.mjs';
@@ -10,6 +11,7 @@ import { runNodeCapture as runNode } from './testkit/core/run_node_capture.mjs';
 import { spawnTestProcess } from './testkit/core/spawn_test_process.mjs';
 import { createTempFixture } from './testkit/core/temp_fixture.mjs';
 import { createStackHappierCliCommandFixture } from './testkit/stack_happier_cli_command_testkit.mjs';
+import { recordStackRuntimeStart } from './utils/stack/runtime_state.mjs';
 
 const scriptsDir = dirname(fileURLToPath(import.meta.url));
 const rootDir = dirname(scriptsDir);
@@ -60,6 +62,33 @@ async function writeServerScopedAuth({ cliHomeDir, serverUrl, env = {} }) {
 }
 
 function buildStubHappyCliScript() {
+  const daemonChildSource = `
+const { createServer } = require('node:http');
+const { mkdirSync, writeFileSync } = require('node:fs');
+const { dirname } = require('node:path');
+const statePath = process.argv[1];
+const controlToken = 'stack-daemon-fixture';
+const server = createServer((req, res) => {
+  if (req.method === 'POST' && req.url === '/ping' && req.headers['x-happier-daemon-token'] === controlToken) {
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ ok: true, distClosureFingerprint: '0000000000000000' }));
+    return;
+  }
+  res.writeHead(404).end();
+});
+server.listen(0, '127.0.0.1', () => {
+  mkdirSync(dirname(statePath), { recursive: true });
+  writeFileSync(statePath, JSON.stringify({
+    pid: process.pid,
+    httpPort: server.address().port,
+    controlToken,
+    startTime: new Date().toISOString(),
+  }) + '\\n', 'utf-8');
+});
+const shutdown = () => server.close(() => process.exit(0));
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+`;
   return `
 import { spawn } from 'node:child_process';
 import { existsSync, readFileSync, writeFileSync, rmSync } from 'node:fs';
@@ -107,9 +136,8 @@ if (sub === 'start') {
   append('direct_peer_advertised_hosts=' + String(process.env.HAPPIER_MACHINE_TRANSFER_DIRECT_PEER_ADVERTISED_HOSTS || ''));
   append('direct_peer_feature_enabled=' + String(process.env.HAPPIER_FEATURE_MACHINES_TRANSFER_DIRECT_PEER__ENABLED || ''));
   append('direct_peer_server_enabled=' + String(process.env.HAPPIER_MACHINE_TRANSFER_DIRECT_PEER_SERVER_ENABLED || ''));
-  const child = spawn(process.execPath, ['-e', 'setInterval(() => {}, 1000)'], { detached: true, stdio: 'ignore' });
+  const child = spawn(process.execPath, ['-e', ${JSON.stringify(daemonChildSource)}, state], { detached: true, stdio: 'ignore' });
   child.unref();
-  writeFileSync(state, JSON.stringify({ pid: child.pid, httpPort: 0, startTime: new Date().toISOString() }) + '\\n', 'utf-8');
   process.exit(0);
 }
 
@@ -134,10 +162,11 @@ process.exit(0);
 }
 
 async function createDaemonFixture(t, { prefix, stackName = 'exp-test', serverPort = 4101 } = {}) {
+  const resolvedServerPort = await reserveUnusedPort(serverPort);
   const fixture = await createStackHappierCliCommandFixture(t, {
     prefix,
     stackName,
-    serverPort,
+    serverPort: resolvedServerPort,
     distIndexScript: buildStubHappyCliScript().trimStart(),
     binHappierScript: "import '../dist/index.mjs';\n",
   });
@@ -145,13 +174,49 @@ async function createDaemonFixture(t, { prefix, stackName = 'exp-test', serverPo
   return {
     storageDir: fixture.storageDir,
     stackName: fixture.stackName,
-    serverPort,
+    serverPort: resolvedServerPort,
     stackCliHome: fixture.stackCliHome,
     baseEnv: fixture.baseEnv,
     writeStackEnv: fixture.writeStackEnv,
   };
 }
 
+async function reserveUnusedPort(preferredPort) {
+  const requested = Number(preferredPort);
+  if (Number.isFinite(requested) && requested > 0) {
+    const claimed = await tryClaimPort(requested);
+    if (claimed) return claimed;
+  }
+  const ephemeral = await tryClaimPort(0);
+  if (!ephemeral) {
+    throw new Error('failed to reserve an unused localhost port for stack daemon integration test');
+  }
+  return ephemeral;
+}
+
+async function tryClaimPort(port) {
+  const server = createServer((_, res) => {
+    res.statusCode = 204;
+    res.end();
+  });
+  try {
+    await new Promise((resolve, reject) => {
+      server.once('error', reject);
+      server.listen(port, '127.0.0.1', resolve);
+    });
+    const address = server.address();
+    const claimedPort = typeof address === 'object' && address ? Number(address.port) : NaN;
+    if (!Number.isFinite(claimedPort) || claimedPort <= 0) {
+      return null;
+    }
+    return claimedPort;
+  } catch {
+    return null;
+  } finally {
+    await new Promise((resolve) => server.close(resolve)).catch(() => {});
+  }
+}
+
 async function readLogText(logPath) {
   return await readFile(logPath, 'utf-8').then(String);
 }
@@ -194,6 +259,12 @@ test('hstack stack daemon <name> start records daemon pid in stack.runtime.json
   await fixture.writeStackEnv();
   registerDaemonCleanup(t, { env: fixture.baseEnv, stackName: fixture.stackName });
 
+  const runtimePath = join(fixture.storageDir, fixture.stackName, 'stack.runtime.json');
+  await recordStackRuntimeStart(runtimePath, {
+    stackName: fixture.stackName,
+    ownerPid: process.pid,
+  });
+
   const startRes = await runHstack(['stack', 'daemon', fixture.stackName, 'start', '--json'], { env: fixture.baseEnv });
   assertExitOk(startRes, 'stack daemon start');
 
@@ -203,7 +274,6 @@ test('hstack stack daemon <name> start records daemon pid in stack.runtime.json
   const pidFromDaemon = Number(state?.pid);
   assert.ok(Number.isFinite(pidFromDaemon) && pidFromDaemon > 1, `expected pid in daemon.state.json, got ${pidFromDaemon}`);
 
-  const runtimePath = join(fixture.storageDir, fixture.stackName, 'stack.runtime.json');
   assert.equal(existsSync(runtimePath), true, 'expected stack.runtime.json to exist after daemon start');
   const runtime = JSON.parse(await readFile(runtimePath, 'utf-8'));
   const pidFromRuntime = Number(runtime?.processes?.daemonPid);
@@ -421,6 +491,43 @@ test('hstack stack daemon <name> status falls back when cli dist entrypoint is m
   );
 });
 
+test('hstack stack daemon <name> status falls back when cli dist entrypoint import graph is incomplete', async (t) => {
+  const fixture = await createDaemonFixture(t, {
+    prefix: 'happy-stacks-daemon-status-incomplete-import-',
+    stackName: 'exp-test',
+    serverPort: 4101,
+  });
+
+  await writeDummyAuth({ cliHomeDir: fixture.stackCliHome });
+  await fixture.writeStackEnv();
+  registerDaemonCleanup(t, { env: fixture.baseEnv, stackName: fixture.stackName });
+
+  const startRes = await runHstack(['stack', 'daemon', fixture.stackName, 'start', '--json'], { env: fixture.baseEnv });
+  assertExitOk(startRes, 'stack daemon start for incomplete-import fallback status');
+
+  const distDir = join(fixture.baseEnv.HAPPIER_STACK_WORKSPACE_DIR, 'happier', 'apps', 'cli', 'dist');
+  await writeFile(join(distDir, 'broken-export.mjs'), 'export const present = true;\n', 'utf-8');
+  await writeFile(
+    join(distDir, 'index.mjs'),
+    "import { missing } from './broken-export.mjs';\nconsole.log(missing);\n",
+    'utf-8',
+  );
+
+  const statusRes = await runHstack(['stack', 'daemon', fixture.stackName, 'status', '--json'], { env: fixture.baseEnv });
+  assertExitOk(statusRes, 'stack daemon status incomplete-import fallback');
+
+  const parsed = JSON.parse(statusRes.stdout.trim());
+  const statusText = String(parsed?.status ?? '');
+  assert.ok(
+    statusText.includes('Fallback status used because CLI dist entrypoint is missing'),
+    `expected fallback marker in daemon status output\n${statusText}`
+  );
+  assert.ok(
+    statusText.includes('Daemon Status'),
+    `expected daemon status section in incomplete-import fallback output\n${statusText}`
+  );
+});
+
 test('hstack stack daemon <name> start uses runtime server port when env port is missing', async (t) => {
   const fixture = await createDaemonFixture(t, {
     prefix: 'happy-stacks-stack-daemon-runtime-port-',

package/scripts/stack_guided_login_inner_invocation.test.mjs

@@ -8,15 +8,26 @@ import { assertGuidedAuthWebappReadyOrThrow, buildStackAuthLoginInvocation } fro
 import { createAuthStackFixture, getStackRootFromMeta } from './testkit/auth_testkit.mjs';
 import { writeRuntimeSnapshotLayout } from './testkit/core/runtime_snapshot_layout.mjs';
 
+function assertCoreAuthLoginInvocation(invocation) {
+  assert.ok(Array.isArray(invocation?.args));
+  if (invocation.command === process.execPath) {
+    assert.match(
+      String(invocation.args[0] ?? ''),
+      /apps\/cli\/(package-dist\/index\.mjs|dist\/index\.mjs|bin\/happier\.mjs)$/,
+    );
+    assert.deepEqual(invocation.args.slice(1), ['auth', 'login']);
+    return;
+  }
+  assert.equal(typeof invocation.command, 'string');
+  assert.notEqual(invocation.command.trim(), '');
+  assert.deepEqual(invocation.args, ['auth', 'login']);
+}
+
 test('guided stack auth login invokes core happier auth login directly', async () => {
   const rootDir = getStackRootFromMeta(import.meta.url);
   const webappUrl = 'http://localhost:1234';
   const inv = await buildStackAuthLoginInvocation({ rootDir, stackName: 'main', webappUrl });
-  assert.ok(Array.isArray(inv?.args));
-  assert.equal(inv.command, process.execPath);
-  assert.match(String(inv.args[0] ?? ''), /apps\/cli\/(package-dist\/index\.mjs|bin\/happier\.mjs)$/);
-  assert.equal(inv.args[1], 'auth');
-  assert.equal(inv.args[2], 'login');
+  assertCoreAuthLoginInvocation(inv);
   assert.equal(inv?.env?.HAPPIER_WEBAPP_URL, webappUrl);
   assert.notEqual(inv?.env?.HAPPIER_STACK_AUTH_INNER, '1');
 });
@@ -25,8 +36,7 @@ test('guided stack auth login defaults stack name to main and preserves invocati
   const rootDir = getStackRootFromMeta(import.meta.url);
   const webappUrl = 'http://localhost:4321';
   const inv = await buildStackAuthLoginInvocation({ rootDir, stackName: '   ', webappUrl });
-  assert.equal(inv.args[1], 'auth');
-  assert.equal(inv.args[2], 'login');
+  assertCoreAuthLoginInvocation(inv);
   assert.equal(inv.env.HAPPIER_WEBAPP_URL, webappUrl);
 });
 

package/scripts/stack_happy_cmd.integration.test.mjs

@@ -5,15 +5,24 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { runNodeCapture } from './testkit/stack_script_command_testkit.mjs';
 import { createStackHappierCliCommandFixture } from './testkit/stack_happier_cli_command_testkit.mjs';
+import { createRuntimeSnapshotFixture } from './testkit/runtime_snapshot_testkit.mjs';
+import { buildStackStableScopeId } from './utils/auth/stable_scope_id.mjs';
 
 const scriptsDir = dirname(fileURLToPath(import.meta.url));
 const rootDir = dirname(scriptsDir);
 
 function buildStubHappyCliScript({ message }) {
   return [
+      `import { appendFileSync } from 'node:fs';`,
+      `import { join } from 'node:path';`,
+      `const args = process.argv.slice(2);`,
+      `if (args[0] === 'server' && args[1] === 'set') {`,
+      `  appendFileSync(join(process.env.HAPPIER_HOME_DIR, '.hstack-test-server-set-calls.ndjson'), JSON.stringify(args) + '\\n');`,
+      `  process.exit(0);`,
+      `}`,
       `console.log(JSON.stringify({`,
       `  message: ${JSON.stringify(message)},`,
-      `  args: process.argv.slice(2),`,
+      `  args,`,
       `  stack: process.env.HAPPIER_STACK_STACK || null,`,
       `  envFile: process.env.HAPPIER_STACK_ENV_FILE || null,`,
       `  homeDir: process.env.HAPPIER_HOME_DIR || null,`,
@@ -25,7 +34,7 @@ function buildStubHappyCliScript({ message }) {
 }
 
 function buildFailingStubHappyCliScript({ errorMessage }) {
-  return `console.error(${JSON.stringify(errorMessage)});\nprocess.exit(1);\n`;
+  return `if (process.env.HAPPIER_CLI_DIST_INTEGRITY_PROBE === 'daemon-command') process.exit(0);\nconsole.error(${JSON.stringify(errorMessage)});\nprocess.exit(1);\n`;
 }
 
 async function createHappyStackFixture(
@@ -174,7 +183,7 @@ test('hstack stack happier <name> ignores stale cloud settings defaults and keep
   assert.equal(out.webappUrl, 'http://localhost:44123');
 });
 
-test('hstack stack happier <name> seeds stack server profile in CLI settings for env-hardened subcommands', async (t) => {
+test('hstack stack happier <name> delegates stack profile reconciliation to the selected CLI runtime', async (t) => {
   const fixture = await createHappyStackFixture(t, {
     prefix: 'happier-stack-stack-happy-seed-settings-',
     message: 'seed-settings',
@@ -198,6 +207,7 @@ test('hstack stack happier <name> seeds stack server profile in CLI settings for
   });
 
   const settingsPath = join(fixture.storageDir, fixture.stackName, 'cli', 'settings.json');
+  const serverSetCallsPath = join(fixture.storageDir, fixture.stackName, 'cli', '.hstack-test-server-set-calls.ndjson');
 
   const res = await runNodeCapture([join(rootDir, 'bin', 'hstack.mjs'), 'stack', 'happier', fixture.stackName], {
     cwd: rootDir,
@@ -209,12 +219,24 @@ test('hstack stack happier <name> seeds stack server profile in CLI settings for
   assert.equal(out.message, 'seed-settings');
   assert.ok(out.activeServerId, 'expected wrapper to export HAPPIER_ACTIVE_SERVER_ID');
 
+  const serverSetCalls = (await readFile(serverSetCallsPath, 'utf-8')).trim().split('\n').map((line) => JSON.parse(line));
+  assert.deepEqual(serverSetCalls, [[
+    'server',
+    'set',
+    '--server-id',
+    out.activeServerId,
+    '--server-url',
+    'http://127.0.0.1:45123',
+    '--local-server-url',
+    'http://127.0.0.1:45123',
+    '--webapp-url',
+    'http://localhost:45123',
+    '--migrate-matching-profile-state',
+    '--json',
+  ]]);
+
   const settings = JSON.parse(await readFile(settingsPath, 'utf-8'));
-  assert.equal(settings.schemaVersion, 6);
-  assert.equal(settings.activeServerId, out.activeServerId);
-  assert.ok(settings.servers?.[out.activeServerId], `expected settings.servers[${out.activeServerId}] to exist`);
-  assert.equal(settings.servers[out.activeServerId].serverUrl, 'http://127.0.0.1:45123');
-  assert.equal(settings.servers[out.activeServerId].webappUrl, 'http://localhost:45123');
+  assert.equal(settings.activeServerId, 'cloud', 'the wrapper must not mutate settings behind the CLI owner');
 });
 
 test('hstack stack happier <name> uses stack.runtime.json ports when env file does not pin HAPPIER_STACK_SERVER_PORT', async (t) => {
@@ -240,6 +262,30 @@ test('hstack stack happier <name> uses stack.runtime.json ports when env file do
   assert.equal(out.serverUrl, 'http://127.0.0.1:4777');
 });
 
+test('hstack stack happier <name> forwards wrapper runtime flags to happier.mjs', async (t) => {
+  const fixture = await createRuntimeSnapshotFixture(t, {
+    stackName: 'runtime-wrapper-passthrough',
+    cliEntrypoint: 'cli/happier.mjs',
+    cliSource: 'process.stdout.write("SNAPSHOT WRAPPER HELP\\n");\n',
+  });
+
+  const res = await runNodeCapture(
+    [join(rootDir, 'bin', 'hstack.mjs'), 'stack', 'happier', fixture.stackName, '--runtime', '--', '--help'],
+    {
+      cwd: rootDir,
+      env: {
+        ...process.env,
+        HAPPIER_STACK_STORAGE_DIR: fixture.storageDir,
+        HAPPIER_STACK_CLI_ROOT_DISABLE: '1',
+        HAPPIER_STACK_REPO_DIR: fixture.root,
+      },
+    },
+  );
+
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  assert.match(res.stdout, /SNAPSHOT WRAPPER HELP/);
+});
+
 test('hstack happier (HAPPIER_STACK_STACK set) uses stack.runtime.json ports when env file does not pin HAPPIER_STACK_SERVER_PORT', async (t) => {
   const fixture = await createHappyStackFixture(t, {
     prefix: 'happier-stack-happy-runtime-ports-',
@@ -251,13 +297,18 @@ test('hstack happier (HAPPIER_STACK_STACK set) uses stack.runtime.json ports whe
     runtimeServerPid: process.pid,
   });
 
+  const env = {
+    ...fixture.baseEnv,
+    HAPPIER_STACK_STACK: fixture.stackName,
+    HAPPIER_STACK_ENV_FILE: join(fixture.storageDir, fixture.stackName, 'env'),
+    HAPPIER_STACK_RUNTIME_MODE: 'source',
+  };
+  delete env.HAPPIER_STACK_SERVER_PORT_BASE;
+  delete env.HAPPIER_STACK_SERVER_PORT_RANGE;
+
   const res = await runNodeCapture([join(rootDir, 'bin', 'happier.mjs')], {
     cwd: rootDir,
-    env: {
-      ...fixture.baseEnv,
-      HAPPIER_STACK_STACK: fixture.stackName,
-      HAPPIER_STACK_ENV_FILE: join(fixture.storageDir, fixture.stackName, 'env'),
-    },
+    env,
   });
   assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
 
@@ -268,7 +319,7 @@ test('hstack happier (HAPPIER_STACK_STACK set) uses stack.runtime.json ports whe
   assert.equal(out.webappUrl, 'http://localhost:4888');
 });
 
-test('hstack happier prefers the matching stack server profile id over the stable scope id', async (t) => {
+test('hstack happier keeps the stable scope when another settings profile matches the stack URL', async (t) => {
   const fixture = await createHappyStackFixture(t, {
     prefix: 'happier-stack-explicit-stack-scope-',
     message: 'explicit-stack-scope',
@@ -294,6 +345,7 @@ test('hstack happier prefers the matching stack server profile id over the stabl
   const env = {
     ...fixture.baseEnv,
     HAPPIER_STACK_STACK: fixture.stackName,
+    HAPPIER_STACK_RUNTIME_MODE: 'source',
   };
   delete env.HAPPIER_STACK_ENV_FILE;
 
@@ -310,7 +362,10 @@ test('hstack happier prefers the matching stack server profile id over the stabl
   assert.equal(out.homeDir, join(fixture.storageDir, fixture.stackName, 'cli'));
   assert.equal(out.serverUrl, 'http://127.0.0.1:5123');
   assert.equal(out.webappUrl, 'http://localhost:5123');
-  assert.equal(out.activeServerId, 'stack-local');
+  assert.equal(
+    out.activeServerId,
+    buildStackStableScopeId({ stackName: fixture.stackName, cliIdentity: 'default' }),
+  );
 });
 
 test('hstack stack happier <name> --identity=<name> uses identity-scoped HAPPIER_HOME_DIR', async (t) => {