@happier-dev/stack 0.1.0-preview.5.1

package/scripts/auth_login_force_default.test.mjs

@@ -0,0 +1,66 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createAuthStackFixture, getStackRootFromMeta, hstackBinPath, runNodeCapture } from './testkit/auth_testkit.mjs';
+
+const BASE_ENV_LINES = [
+  'HAPPIER_STACK_STACK=main',
+  'HAPPIER_STACK_SERVER_PORT=4102',
+  'HAPPIER_STACK_TAILSCALE_PREFER_PUBLIC_URL=0',
+  'HAPPIER_STACK_TAILSCALE_SERVE=0',
+];
+
+async function runLoginPrintJson({ rootDir, fixture, args = [] }) {
+  const res = await runNodeCapture(
+    [hstackBinPath(rootDir), 'auth', 'login', '--print', '--no-open', '--json', ...args],
+    { cwd: rootDir, env: fixture.buildEnv() }
+  );
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstderr:\n${res.stderr}\nstdout:\n${res.stdout}`);
+  return JSON.parse(res.stdout.trim());
+}
+
+test('hstack auth login does not pass --force by default', async () => {
+  const rootDir = getStackRootFromMeta(import.meta.url);
+  const fixture = await createAuthStackFixture({
+    prefix: 'hstack-auth-force-default-',
+    stackEnvLines: BASE_ENV_LINES,
+  });
+  try {
+    const parsed = await runLoginPrintJson({ rootDir, fixture });
+    assert.doesNotMatch(parsed.cmd, /\s--force(\s|$)/, `expected command to omit --force by default\n${parsed.cmd}`);
+  } finally {
+    await fixture.cleanup();
+  }
+});
+
+test('hstack auth login passes --force when explicitly requested', async () => {
+  const rootDir = getStackRootFromMeta(import.meta.url);
+  const fixture = await createAuthStackFixture({
+    prefix: 'hstack-auth-force-explicit-',
+    stackEnvLines: BASE_ENV_LINES,
+  });
+  try {
+    const parsed = await runLoginPrintJson({ rootDir, fixture, args: ['--force'] });
+    assert.match(parsed.cmd, /\s--force(\s|$)/, `expected command to include --force when requested\n${parsed.cmd}`);
+  } finally {
+    await fixture.cleanup();
+  }
+});
+
+test('hstack auth login prints stable active server scope env by default', async () => {
+  const rootDir = getStackRootFromMeta(import.meta.url);
+  const fixture = await createAuthStackFixture({
+    prefix: 'hstack-auth-scope-env-',
+    stackEnvLines: BASE_ENV_LINES,
+  });
+  try {
+    const parsed = await runLoginPrintJson({ rootDir, fixture });
+    assert.match(
+      parsed.cmd,
+      /HAPPIER_ACTIVE_SERVER_ID="stack_main__id_default"/,
+      `expected printed command to include stable scope env\n${parsed.cmd}`
+    );
+  } finally {
+    await fixture.cleanup();
+  }
+});

package/scripts/auth_login_guided_server_no_expo.test.mjs

@@ -0,0 +1,126 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { authScriptPath, runNodeCapture } from './testkit/auth_testkit.mjs';
+
+async function ensureMinimalMonorepoWithStubCli({ monoRoot }) {
+  await mkdir(join(monoRoot, 'apps', 'ui'), { recursive: true });
+  await mkdir(join(monoRoot, 'apps', 'cli', 'bin'), { recursive: true });
+  await mkdir(join(monoRoot, 'apps', 'cli', 'dist'), { recursive: true });
+  await mkdir(join(monoRoot, 'apps', 'server'), { recursive: true });
+  await writeFile(join(monoRoot, 'apps', 'ui', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'cli', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'server', 'package.json'), '{}\n', 'utf-8');
+
+  // startLocalDaemonWithAuth() checks for dist/index.mjs existence even if we never get there.
+  await writeFile(join(monoRoot, 'apps', 'cli', 'dist', 'index.mjs'), 'export {};\n', 'utf-8');
+
+  // Stub `happier` CLI: accept any args and exit 0 (keeps the test non-interactive).
+  await writeFile(
+    join(monoRoot, 'apps', 'cli', 'bin', 'happier.mjs'),
+    "process.exit(0);\n",
+    'utf-8'
+  );
+}
+
+async function createHealthyServer() {
+  const server = createServer((req, res) => {
+    if (req.url === '/health') {
+      res.statusCode = 200;
+      res.setHeader('content-type', 'application/json');
+      res.end(JSON.stringify({ status: 'ok', service: 'happier-server' }));
+      return;
+    }
+    res.statusCode = 200;
+    res.end('ok');
+  });
+  await new Promise((resolvePromise, rejectPromise) => {
+    server.once('error', rejectPromise);
+    server.listen(0, '127.0.0.1', resolvePromise);
+  });
+  const port = server.address()?.port;
+  assert.ok(Number.isFinite(port) && port > 0, `expected listening port, got ${String(port)}`);
+  return { server, port };
+}
+
+async function buildGuidedNoExpoFixture() {
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-auth-guided-no-expo-'));
+  const storageDir = join(tmp, 'storage');
+  const monoRoot = join(tmp, 'happier');
+  await ensureMinimalMonorepoWithStubCli({ monoRoot });
+
+  const { server, port } = await createHealthyServer();
+  await mkdir(join(storageDir, 'main'), { recursive: true });
+  const envPath = join(storageDir, 'main', 'env');
+  await writeFile(
+    envPath,
+    [
+      'HAPPIER_STACK_STACK=main',
+      `HAPPIER_STACK_REPO_DIR=${monoRoot}`,
+      `HAPPIER_STACK_SERVER_PORT=${port}`,
+      'HAPPIER_STACK_TAILSCALE_PREFER_PUBLIC_URL=0',
+      'HAPPIER_STACK_TAILSCALE_SERVE=0',
+      '',
+    ].join('\n'),
+    'utf-8'
+  );
+
+  await writeFile(join(storageDir, 'main', 'stack.runtime.json'), JSON.stringify({ version: 1, stackName: 'main', ports: {} }) + '\n', 'utf-8');
+
+  return {
+    tmp,
+    server,
+    port,
+    env: {
+      ...process.env,
+      HAPPIER_STACK_STORAGE_DIR: storageDir,
+      HAPPIER_STACK_STACK: 'main',
+      HAPPIER_STACK_ENV_FILE: envPath,
+      HAPPIER_STACK_TEST_TTY: '1',
+      HAPPIER_STACK_AUTH_FLOW: '0',
+      HAPPIER_STACK_AUTH_UI_READY_TIMEOUT_MS: '1',
+      HAPPIER_NO_BROWSER_OPEN: '1',
+    },
+    async cleanup() {
+      await new Promise((resolvePromise) => server.close(resolvePromise));
+      await rm(tmp, { recursive: true, force: true }).catch(() => {});
+    },
+  };
+}
+
+test('guided auth login fails closed when Expo web UI is not ready (does not fall back to server URL)', async (t) => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+
+  let fixture;
+  try {
+    try {
+      fixture = await buildGuidedNoExpoFixture();
+    } catch (e) {
+      if (e && typeof e === 'object' && 'code' in e && e.code === 'EPERM') {
+        t.skip('sandbox disallows binding localhost test server (EPERM)');
+        return;
+      }
+      throw e;
+    }
+    const res = await runNodeCapture([authScriptPath(rootDir), 'login', '--method', 'web'], {
+      cwd: rootDir,
+      env: fixture.env,
+      input: '\n\n',
+    });
+    assert.notStrictEqual(res.code, 0, `expected non-zero exit when Expo is unavailable\nstderr:\n${res.stderr}\nstdout:\n${res.stdout}`);
+    assert.match(res.stderr, /attempted to start stack UI in background/i, `stderr:\n${res.stderr}`);
+    assert.match(
+      res.stderr,
+      /guid(ed)? login web UI is still not ready|startup failed/i,
+      `stderr:\n${res.stderr}`
+    );
+    assert.doesNotMatch(res.stdout, new RegExp(`URL: http://localhost:${fixture.port}\\b`), `stdout:\n${res.stdout}`);
+  } finally {
+    if (fixture) await fixture.cleanup();
+  }
+});

package/scripts/auth_login_method_override.test.mjs

@@ -0,0 +1,67 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createAuthStackFixture, getStackRootFromMeta, hstackBinPath, runNodeCapture } from './testkit/auth_testkit.mjs';
+
+test('hstack auth login --method=mobile sets HAPPIER_AUTH_METHOD in --print --json output', async () => {
+  const rootDir = getStackRootFromMeta(import.meta.url);
+
+  const fixture = await createAuthStackFixture({
+    prefix: 'hstack-auth-method-',
+    stackEnvLines: [
+      'HAPPIER_STACK_STACK=main',
+      'HAPPIER_STACK_SERVER_PORT=4102',
+      'HAPPIER_STACK_TAILSCALE_PREFER_PUBLIC_URL=0',
+      'HAPPIER_STACK_TAILSCALE_SERVE=0',
+    ],
+  });
+  try {
+    const res = await runNodeCapture(
+      [
+        hstackBinPath(rootDir),
+        'auth',
+        'login',
+        '--print',
+        '--no-open',
+        '--json',
+        '--method=mobile',
+      ],
+      { cwd: rootDir, env: fixture.buildEnv() }
+    );
+    assert.equal(res.code, 0, `expected exit 0, got ${res.code} (signal=${res.signal ?? 'none'})\nstderr:\n${res.stderr}\nstdout:\n${res.stdout}`);
+    const parsed = JSON.parse(res.stdout.trim());
+    assert.ok(
+      parsed?.cmd?.includes('HAPPIER_AUTH_METHOD="mobile"'),
+      `expected printed cmd to include HAPPIER_AUTH_METHOD\n${parsed?.cmd}`
+    );
+  } finally {
+    await fixture.cleanup();
+  }
+});
+
+test('hstack auth login invalid --method error mentions browser alias', async () => {
+  const rootDir = getStackRootFromMeta(import.meta.url);
+
+  const fixture = await createAuthStackFixture({
+    prefix: 'hstack-auth-method-invalid-',
+    stackEnvLines: ['HAPPIER_STACK_STACK=main'],
+  });
+  try {
+    const res = await runNodeCapture(
+      [
+        hstackBinPath(rootDir),
+        'auth',
+        'login',
+        '--method=invalid',
+      ],
+      { cwd: rootDir, env: fixture.buildEnv() }
+    );
+
+    assert.ok(res.code !== 0 || res.signal, `expected non-zero exit for invalid --method\nstdout:\n${res.stdout}`);
+    assert.match(res.stderr, /invalid --method=invalid/, `expected invalid method label in error\nstderr:\n${res.stderr}`);
+    assert.match(res.stderr, /\bweb\b/, `expected web alias in error\nstderr:\n${res.stderr}`);
+    assert.match(res.stderr, /\bbrowser\b/, `expected browser alias in error\nstderr:\n${res.stderr}`);
+    assert.match(res.stderr, /\bmobile\b/, `expected mobile alias in error\nstderr:\n${res.stderr}`);
+  } finally {
+    await fixture.cleanup();
+  }
+});

package/scripts/auth_login_print_includes_configure_links.test.mjs

@@ -0,0 +1,99 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createAuthStackFixture, getStackRootFromMeta, hstackBinPath, runNodeCapture } from './testkit/auth_testkit.mjs';
+
+const BASE_ENV_LINES = [
+  'HAPPIER_STACK_STACK=main',
+  'HAPPIER_STACK_SERVER_PORT=4102',
+  'HAPPIER_STACK_TAILSCALE_PREFER_PUBLIC_URL=0',
+  'HAPPIER_STACK_TAILSCALE_SERVE=0',
+];
+
+async function runAuthLoginPrintJson({ rootDir, prefix, stackEnvLines, extraEnv = {}, args = [] }) {
+  const fixture = await createAuthStackFixture({
+    prefix,
+    stackEnvLines,
+  });
+  try {
+    const res = await runNodeCapture(
+      [hstackBinPath(rootDir), 'auth', 'login', '--print', '--no-open', '--json', ...args],
+      { cwd: rootDir, env: fixture.buildEnv(extraEnv) }
+    );
+    assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstderr:\n${res.stderr}\nstdout:\n${res.stdout}`);
+    return JSON.parse(res.stdout.trim());
+  } finally {
+    await fixture.cleanup();
+  }
+}
+
+test('hstack auth login --print --json includes configure-server links and public server URL env export', async () => {
+  const rootDir = getStackRootFromMeta(import.meta.url);
+  const parsed = await runAuthLoginPrintJson({
+    rootDir,
+    prefix: 'hstack-auth-links-',
+    stackEnvLines: BASE_ENV_LINES,
+  });
+
+  assert.equal(parsed.internalServerUrl, 'http://127.0.0.1:4102');
+  assert.equal(parsed.publicServerUrl, 'http://localhost:4102');
+  assert.equal(parsed.webappUrl, 'http://localhost:4102');
+  assert.match(parsed.cmd, /HAPPIER_PUBLIC_SERVER_URL="http:\/\/localhost:4102"/);
+
+  assert.ok(parsed.configureServer, 'expected configureServer field');
+  assert.equal(
+    parsed.configureServer.webUrl,
+    `http://localhost:4102/?server=${encodeURIComponent('http://localhost:4102')}`
+  );
+  assert.equal(
+    parsed.configureServer.mobileUrl,
+    `happier://server?url=${encodeURIComponent('http://localhost:4102')}`
+  );
+});
+
+test('hstack auth login --print --json webapp precedence variants', async (t) => {
+  const rootDir = getStackRootFromMeta(import.meta.url);
+  const matrix = [
+    {
+      name: '--webapp-url overrides computed webappUrl',
+      prefix: 'hstack-auth-webapp-url-',
+      stackEnvLines: BASE_ENV_LINES,
+      args: ['--webapp-url=http://example.test:1234'],
+      assertParsed(parsed) {
+        assert.equal(parsed.webappUrl, 'http://example.test:1234');
+        assert.match(parsed.cmd, /HAPPIER_WEBAPP_URL="http:\/\/example\.test:1234"/);
+      },
+    },
+    {
+      name: '--webapp=public overrides stack-env hosted webapp',
+      prefix: 'hstack-auth-webapp-public-',
+      stackEnvLines: [...BASE_ENV_LINES, 'HAPPIER_WEBAPP_URL=https://app.happier.dev'],
+      args: ['--webapp=public'],
+      assertParsed(parsed) {
+        assert.equal(parsed.webappUrl, 'http://localhost:4102');
+      },
+    },
+    {
+      name: 'main stack ignores global HAPPIER_WEBAPP_URL when stack env does not define it',
+      prefix: 'hstack-auth-main-webapp-',
+      stackEnvLines: ['HAPPIER_STACK_STACK=main', 'HAPPIER_STACK_TAILSCALE_PREFER_PUBLIC_URL=0', 'HAPPIER_STACK_TAILSCALE_SERVE=0'],
+      extraEnv: { HAPPIER_WEBAPP_URL: 'https://app.happier.dev' },
+      assertParsed(parsed) {
+        assert.ok(parsed.webappUrl, 'expected webappUrl in output');
+        assert.notEqual(parsed.webappUrl, 'https://app.happier.dev');
+      },
+    },
+  ];
+
+  for (const scenario of matrix) {
+    await t.test(scenario.name, async () => {
+      const parsed = await runAuthLoginPrintJson({
+        rootDir,
+        prefix: scenario.prefix,
+        stackEnvLines: scenario.stackEnvLines,
+        extraEnv: scenario.extraEnv,
+        args: scenario.args,
+      });
+      scenario.assertParsed(parsed);
+    });
+  }
+});

package/scripts/auth_status_server_validation.integration.test.mjs

@@ -0,0 +1,140 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+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 { authScriptPath, runNodeCapture } from './testkit/auth_testkit.mjs';
+
+function credentialsWithToken(token) {
+  return JSON.stringify({
+    token,
+    secret: Buffer.from('test-secret').toString('base64'),
+  });
+}
+
+async function startStubAuthServer({ profileStatusCode, profileBody, expectedToken }) {
+  const server = createServer((req, res) => {
+    if (!req.url) {
+      res.statusCode = 500;
+      res.end('missing url');
+      return;
+    }
+    if (req.url === '/health') {
+      res.statusCode = 200;
+      res.setHeader('content-type', 'application/json');
+      res.end(JSON.stringify({ status: 'ok', service: 'happier-server' }));
+      return;
+    }
+    if (req.url === '/v1/account/profile') {
+      const auth = String(req.headers.authorization ?? '');
+      const token = auth.startsWith('Bearer ') ? auth.slice('Bearer '.length) : '';
+      if (expectedToken && token !== expectedToken) {
+        res.statusCode = 500;
+        res.setHeader('content-type', 'application/json');
+        res.end(JSON.stringify({ error: `unexpected token: ${token}` }));
+        return;
+      }
+      res.statusCode = profileStatusCode;
+      res.setHeader('content-type', 'application/json');
+      res.end(JSON.stringify(profileBody));
+      return;
+    }
+    res.statusCode = 404;
+    res.setHeader('content-type', 'application/json');
+    res.end(JSON.stringify({ error: 'not-found' }));
+  });
+
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const address = server.address();
+  if (!address || typeof address === 'string') {
+    throw new Error('failed to resolve stub server address');
+  }
+  return {
+    server,
+    port: address.port,
+    close: async () => {
+      await new Promise((resolve, reject) => server.close((err) => (err ? reject(err) : resolve())));
+    },
+  };
+}
+
+test('hstack stack auth status marks credentials invalid when server rejects token with reason code', async (t) => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-auth-status-server-invalid-'));
+  t.after(async () => {
+    await rm(tmp, { recursive: true, force: true });
+  });
+
+  const cliHomeDir = join(tmp, 'cli');
+  await mkdir(cliHomeDir, { recursive: true });
+  await writeFile(join(cliHomeDir, 'access.key'), credentialsWithToken('bad-token'), 'utf-8');
+
+  const stub = await startStubAuthServer({
+    profileStatusCode: 401,
+    profileBody: { error: 'Invalid token', code: 'account-not-found' },
+    expectedToken: 'bad-token',
+  });
+  t.after(async () => {
+    await stub.close();
+  });
+
+  const env = {
+    ...process.env,
+    HAPPIER_STACK_STACK: 'dev',
+    HAPPIER_STACK_ENV_FILE: join(tmp, 'missing.env'),
+    HAPPIER_STACK_SERVER_PORT: String(stub.port),
+    HAPPIER_STACK_CLI_HOME_DIR: cliHomeDir,
+  };
+
+  const res = await runNodeCapture([authScriptPath(rootDir), '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 payload = JSON.parse(res.stdout);
+  assert.equal(payload.auth.hasAccessKey, true);
+  assert.equal(payload.auth.serverValidation.checked, true);
+  assert.equal(payload.auth.serverValidation.valid, false);
+  assert.equal(payload.auth.serverValidation.status, 401);
+  assert.equal(payload.auth.serverValidation.code, 'account-not-found');
+});
+
+test('hstack stack auth status marks credentials valid when profile endpoint accepts token', async (t) => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-auth-status-server-valid-'));
+  t.after(async () => {
+    await rm(tmp, { recursive: true, force: true });
+  });
+
+  const cliHomeDir = join(tmp, 'cli');
+  await mkdir(cliHomeDir, { recursive: true });
+  await writeFile(join(cliHomeDir, 'access.key'), credentialsWithToken('good-token'), 'utf-8');
+
+  const stub = await startStubAuthServer({
+    profileStatusCode: 200,
+    profileBody: { id: 'acc-1' },
+    expectedToken: 'good-token',
+  });
+  t.after(async () => {
+    await stub.close();
+  });
+
+  const env = {
+    ...process.env,
+    HAPPIER_STACK_STACK: 'dev',
+    HAPPIER_STACK_ENV_FILE: join(tmp, 'missing.env'),
+    HAPPIER_STACK_SERVER_PORT: String(stub.port),
+    HAPPIER_STACK_CLI_HOME_DIR: cliHomeDir,
+  };
+
+  const res = await runNodeCapture([authScriptPath(rootDir), '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 payload = JSON.parse(res.stdout);
+  assert.equal(payload.auth.hasAccessKey, true);
+  assert.equal(payload.auth.serverValidation.checked, true);
+  assert.equal(payload.auth.serverValidation.valid, true);
+  assert.equal(payload.auth.serverValidation.status, 200);
+  assert.equal(payload.auth.serverValidation.code, 'ok');
+});