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

package/scripts/service.mjs

@@ -3,9 +3,11 @@ import { run, runCapture } from './utils/proc/proc.mjs';
 import { getComponentDir, getDefaultAutostartPaths, getRootDir, getSystemdUnitInfo, resolveStackEnvPath } from './utils/paths/paths.mjs';
 import { getInternalServerUrl, getPublicServerUrlEnvOverride } from './utils/server/urls.mjs';
 import { ensureMacAutostartDisabled, ensureMacAutostartEnabled } from './utils/service/autostart_darwin.mjs';
+import { installService as installManagedService, uninstallService as uninstallManagedService } from './utils/service/service_manager.mjs';
 import { getCanonicalHomeDir } from './utils/env/config.mjs';
 import { isSandboxed, sandboxAllowsGlobalSideEffects } from './utils/env/sandbox.mjs';
 import { expandHome } from './utils/paths/canonical_home.mjs';
+import { resolveInstalledCliRoot, resolveInstalledPath } from './utils/paths/runtime.mjs';
 import { spawn } from 'node:child_process';
 import { homedir } from 'node:os';
 import { existsSync } from 'node:fs';
@@ -109,6 +111,33 @@ function ensureLinuxSystemModeSupported({ mode }) {
   }
 }
 
+async function resolveStackAutostartProgramArgs({ rootDir, mode, systemUser }) {
+  const base = getCanonicalHomeDir();
+  const candidates =
+    process.platform === 'win32'
+      ? [join(base, 'bin', 'hstack.exe'), join(base, 'bin', 'hstack.cmd'), join(base, 'bin', 'hstack')]
+      : [join(base, 'bin', 'hstack')];
+
+  let shimPath = candidates.find((p) => existsSync(p)) ?? '';
+  if (mode === 'system' && systemUser) {
+    const home = await resolveHomeDirForUser(systemUser);
+    if (home) {
+      const systemCandidates =
+        process.platform === 'win32'
+          ? [
+              join(home, '.happier-stack', 'bin', 'hstack.exe'),
+              join(home, '.happier-stack', 'bin', 'hstack.cmd'),
+              join(home, '.happier-stack', 'bin', 'hstack'),
+            ]
+          : [join(home, '.happier-stack', 'bin', 'hstack')];
+      shimPath = systemCandidates.find((p) => existsSync(p)) ?? shimPath;
+    }
+  }
+
+  if (shimPath) return [shimPath, 'start'];
+  return [process.execPath, resolveInstalledPath(rootDir, 'bin/hstack.mjs'), 'start'];
+}
+
 export async function installService({ mode = 'user', systemUser = null } = {}) {
   if (isSandboxed() && !sandboxAllowsGlobalSideEffects()) {
     throw new Error(
@@ -118,11 +147,8 @@ export async function installService({ mode = 'user', systemUser = null } = {})
     );
   }
   ensureLinuxSystemModeSupported({ mode });
-  if (process.platform !== 'darwin' && process.platform !== 'linux') {
-    throw new Error('[local] service install is only supported on macOS (launchd) and Linux (systemd).');
-  }
   const rootDir = getRootDir(import.meta.url);
-  const { label } = getDefaultAutostartPaths();
+  const { label, stdoutPath, stderrPath, baseDir } = getDefaultAutostartPaths();
   const env = getAutostartEnv({ rootDir, mode });
   // Ensure the env file exists so the service never points at a missing path.
   try {
@@ -137,17 +163,43 @@ export async function installService({ mode = 'user', systemUser = null } = {})
   } catch {
     // ignore
   }
+  const programArgs = await resolveStackAutostartProgramArgs({ rootDir, mode, systemUser });
+  const workingDirectory =
+    process.platform === 'linux'
+      ? '%h'
+      : process.platform === 'darwin'
+        ? resolveInstalledCliRoot(rootDir)
+        : baseDir;
+
+  await installManagedService({
+    platform: process.platform,
+    mode,
+    homeDir: homedir(),
+    spec: {
+      label,
+      description: `Happier Stack (${label})`,
+      programArgs,
+      workingDirectory,
+      env,
+      runAsUser: mode === 'system' && systemUser ? systemUser : '',
+      stdoutPath,
+      stderrPath,
+    },
+    persistent: true,
+  });
+
+  if (process.platform === 'win32') {
+    console.log(`${green('✓')} service installed ${dim('(Windows scheduled task)')}`);
+    return;
+  }
   if (process.platform === 'darwin') {
-    await ensureMacAutostartEnabled({ rootDir, label, env });
     console.log(`${green('✓')} service installed ${dim('(macOS launchd)')}`);
     return;
   }
   if (mode === 'system') {
-    await ensureSystemdSystemServiceEnabled({ rootDir, label, env, systemUser });
     console.log(`${green('✓')} service installed ${dim('(Linux systemd system)')}`);
     return;
   }
-  await ensureSystemdUserServiceEnabled({ rootDir, label, env });
   console.log(`${green('✓')} service installed ${dim('(Linux systemd --user)')}`);
 }
 
@@ -157,25 +209,40 @@ export async function uninstallService({ mode = 'user' } = {}) {
     return;
   }
   ensureLinuxSystemModeSupported({ mode });
-  if (process.platform !== 'darwin' && process.platform !== 'linux') return;
+  const rootDir = getRootDir(import.meta.url);
+  const { label, stdoutPath, stderrPath, baseDir } = getDefaultAutostartPaths();
+  const env = getAutostartEnv({ rootDir, mode });
+  const programArgs = await resolveStackAutostartProgramArgs({ rootDir, mode, systemUser: null });
+  const workingDirectory =
+    process.platform === 'linux'
+      ? '%h'
+      : process.platform === 'darwin'
+        ? resolveInstalledCliRoot(rootDir)
+        : baseDir;
+
+  await uninstallManagedService({
+    platform: process.platform,
+    mode,
+    homeDir: homedir(),
+    spec: {
+      label,
+      description: `Happier Stack (${label})`,
+      programArgs,
+      workingDirectory,
+      env,
+      stdoutPath,
+      stderrPath,
+    },
+    persistent: true,
+  });
 
-  if (process.platform === 'linux') {
-    if (mode === 'system') {
-      await ensureSystemdSystemServiceDisabled({ remove: true });
-      console.log(`${green('✓')} service uninstalled ${dim('(systemd system unit removed)')}`);
-      return;
-    }
-    await ensureSystemdUserServiceDisabled({ remove: true });
-    console.log(`${green('✓')} service uninstalled ${dim('(systemd user unit removed)')}`);
+  if (process.platform === 'win32') {
+    console.log(`${green('✓')} service uninstalled ${dim('(Windows task removed)')}`);
     return;
   }
-  const { plistPath, label } = getDefaultAutostartPaths();
-
-  await ensureMacAutostartDisabled({ label });
-  try {
-    await rm(plistPath, { force: true });
-  } catch {
-    // ignore
+  if (process.platform === 'linux') {
+    console.log(`${green('✓')} service uninstalled ${dim('(systemd unit removed)')}`);
+    return;
   }
   console.log(`${green('✓')} service uninstalled ${dim('(plist removed)')}`);
 }
@@ -633,8 +700,8 @@ async function main() {
   const systemUser = resolveSystemUser(helpScopeArgv);
   ensureLinuxSystemModeSupported({ mode });
 
-  if (process.platform !== 'darwin' && process.platform !== 'linux') {
-    throw new Error('[local] service commands are only supported on macOS (launchd) and Linux (systemd).');
+  if (process.platform !== 'darwin' && process.platform !== 'linux' && process.platform !== 'win32') {
+    throw new Error('[local] service commands are only supported on macOS (launchd), Linux (systemd), and Windows (schtasks).');
   }
   const positionals = helpScopeArgv.filter((a) => a && a !== '--' && !a.startsWith('-'));
   const cmd = positionals[0] ?? 'help';
@@ -711,7 +778,17 @@ async function main() {
           health = { ok: false, status: null, body: null };
         }
 
-        if (process.platform === 'darwin') {
+        if (process.platform === 'win32') {
+          const { label, stdoutPath, stderrPath } = getDefaultAutostartPaths();
+          const taskName = `Happier\\${label}`;
+          let schtasksStatus = null;
+          try {
+            schtasksStatus = await runCapture('schtasks', ['/Query', '/TN', taskName, '/FO', 'LIST', '/V']);
+          } catch (e) {
+            schtasksStatus = e && typeof e === 'object' && 'out' in e ? e.out : null;
+          }
+          printResult({ json, data: { label, taskName, stdoutPath, stderrPath, internalUrl, schtasksStatus, health } });
+        } else if (process.platform === 'darwin') {
           const { plistPath, stdoutPath, stderrPath, label } = getDefaultAutostartPaths();
           let launchctlLine = null;
           try {
@@ -736,6 +813,11 @@ async function main() {
           printResult({ json, data: { mode, unitName, unitPath, internalUrl, systemctlStatus, health } });
         }
       } else {
+        if (process.platform === 'win32') {
+          const { label } = getDefaultAutostartPaths();
+          await run('schtasks', ['/Query', '/TN', `Happier\\${label}`]);
+          return;
+        }
         if (process.platform === 'darwin') {
           await showStatus();
         } else {
@@ -749,6 +831,13 @@ async function main() {
       }
       return;
     case 'start':
+      if (process.platform === 'win32') {
+        const { label } = getDefaultAutostartPaths();
+        await run('schtasks', ['/Run', '/TN', `Happier\\${label}`]).catch(() => {});
+        await postStartDiagnostics();
+        if (json) printResult({ json, data: { ok: true, action: 'start' } });
+        return;
+      }
       if (process.platform === 'darwin') {
         await startLaunchAgent({ persistent: false });
       } else {
@@ -763,6 +852,12 @@ async function main() {
       if (json) printResult({ json, data: { ok: true, action: 'start' } });
       return;
     case 'stop':
+      if (process.platform === 'win32') {
+        const { label } = getDefaultAutostartPaths();
+        await run('schtasks', ['/End', '/TN', `Happier\\${label}`]).catch(() => {});
+        if (json) printResult({ json, data: { ok: true, action: 'stop' } });
+        return;
+      }
       if (process.platform === 'darwin') {
         await stopLaunchAgent({ persistent: false });
       } else {
@@ -776,6 +871,14 @@ async function main() {
       if (json) printResult({ json, data: { ok: true, action: 'stop' } });
       return;
     case 'restart':
+      if (process.platform === 'win32') {
+        const { label } = getDefaultAutostartPaths();
+        await run('schtasks', ['/End', '/TN', `Happier\\${label}`]).catch(() => {});
+        await run('schtasks', ['/Run', '/TN', `Happier\\${label}`]).catch(() => {});
+        await postStartDiagnostics();
+        if (json) printResult({ json, data: { ok: true, action: 'restart' } });
+        return;
+      }
       if (process.platform === 'darwin') {
         if (!(await restartLaunchAgentBestEffort())) {
           await stopLaunchAgent({ persistent: false });
@@ -794,6 +897,14 @@ async function main() {
       if (json) printResult({ json, data: { ok: true, action: 'restart' } });
       return;
     case 'enable':
+      if (process.platform === 'win32') {
+        const { label } = getDefaultAutostartPaths();
+        await run('schtasks', ['/Change', '/TN', `Happier\\${label}`, '/Enable']).catch(() => {});
+        await run('schtasks', ['/Run', '/TN', `Happier\\${label}`]).catch(() => {});
+        await postStartDiagnostics();
+        if (json) printResult({ json, data: { ok: true, action: 'enable' } });
+        return;
+      }
       if (process.platform === 'darwin') {
         await startLaunchAgent({ persistent: true });
       } else {
@@ -808,6 +919,13 @@ async function main() {
       if (json) printResult({ json, data: { ok: true, action: 'enable' } });
       return;
     case 'disable':
+      if (process.platform === 'win32') {
+        const { label } = getDefaultAutostartPaths();
+        await run('schtasks', ['/End', '/TN', `Happier\\${label}`]).catch(() => {});
+        await run('schtasks', ['/Change', '/TN', `Happier\\${label}`, '/Disable']).catch(() => {});
+        if (json) printResult({ json, data: { ok: true, action: 'disable' } });
+        return;
+      }
       if (process.platform === 'darwin') {
         await stopLaunchAgent({ persistent: true });
       } else {
@@ -821,6 +939,15 @@ async function main() {
       if (json) printResult({ json, data: { ok: true, action: 'disable' } });
       return;
     case 'logs':
+      if (process.platform === 'win32') {
+        const { stdoutPath, stderrPath } = getDefaultAutostartPaths();
+        const out = await readLastLines(stdoutPath, 200).catch(() => '');
+        const err = await readLastLines(stderrPath, 200).catch(() => '');
+        console.log(bullets([kv('stdout:', stdoutPath), kv('stderr:', stderrPath)]));
+        if (out.trim()) console.log(out.trimEnd());
+        if (err.trim()) console.log(err.trimEnd());
+        return;
+      }
       if (process.platform === 'darwin') {
         await showLogs();
       } else {
@@ -834,6 +961,9 @@ async function main() {
       }
       return;
     case 'tail':
+      if (process.platform === 'win32') {
+        throw new Error('[local] service tail is not supported on Windows yet. Use: hstack service logs');
+      }
       if (process.platform === 'darwin') {
         await tailLogs();
       } else {

package/scripts/stack/command_arguments.mjs

@@ -13,6 +13,7 @@ const STACK_NAME_FIRST_SUPPORTED_COMMANDS = new Set([
   'create-dev-auth-seed',
   'daemon',
   'happier',
+  'bug-report',
   'env',
   'auth',
   'dev',

package/scripts/stack/help_text.mjs

@@ -6,10 +6,11 @@ const STACK_HELP_USAGE_LINES = [
   'hstack stack archive <name> [--dry-run] [--date=YYYY-MM-DD] [--json]',
   'hstack stack duplicate <from> <to> [--duplicate-worktrees] [--deps=none|link|install|link-or-install] [--json]',
   'hstack stack info <name> [--json]',
-  'hstack stack pr <name> --repo=<pr-url|number> [--server-flavor=light|full] [--dev|--start] [--json] [-- ...]',
+  'hstack stack pr <name> --repo=<pr-url|number> [--server-flavor=light|full] [--dev|--start] [--reuse] [--update] [--force] [--background] [--mobile] [--expo-tailscale] [--json] [-- ...]',
   'hstack stack create-dev-auth-seed [name] [--server=happier-server|happier-server-light] [--login|--no-login] [--skip-default-seed] [--non-interactive] [--json]',
   'hstack stack daemon <name> start|stop|restart|status [--json]',
   'hstack stack happier <name> [-- ...]',
+  'hstack stack bug-report <name> [-- ...]',
   'hstack stack env <name> set KEY=VALUE [KEY2=VALUE2...] | unset KEY [KEY2...] | get KEY | list | path [--json]',
   'hstack stack auth <name> status|login|copy-from [--json]',
   'hstack stack dev <name> [-- ...]',
@@ -48,6 +49,7 @@ export const STACK_HELP_COMMANDS = [
   'daemon',
   'eas',
   'happier',
+  'bug-report',
   'env',
   'auth',
   'dev',

package/scripts/stack.mjs

@@ -1622,7 +1622,7 @@ async function cmdPrStack({ rootDir, argv }) {
         '[stack] usage:',
         '  hstack stack pr <name> --repo=<pr-url|number> [--dev|--start]',
         '    [--seed-auth] [--copy-auth-from=<stack>] [--link-auth] [--with-infra] [--auth-force]',
-        '    [--remote=upstream] [--deps=none|link|install|link-or-install] [--update] [--force] [--background]',
+        '    [--remote=upstream] [--deps=none|link|install|link-or-install] [--reuse] [--update] [--force] [--background]',
         '    [--mobile]         # also start Expo dev-client Metro for mobile',
         '    [--expo-tailscale] # forward Expo to Tailscale interface for remote access',
         '    [--json] [-- <stack dev/start args...>]',
@@ -1639,6 +1639,7 @@ async function cmdPrStack({ rootDir, argv }) {
         '',
 	        'notes:',
 	        '  - This composes existing commands: `hstack stack new`, `hstack stack wt ...`, and `hstack stack auth ...`',
+	        '  - `--reuse` reuses an existing PR stack (otherwise `stack pr` fails closed if the stack already exists)',
 	        '  - For auth seeding, pass `--seed-auth` and optionally `--copy-auth-from=dev-auth` (or main)',
 	        '  - `--link-auth` symlinks auth files instead of copying (keeps credentials in sync, but reduces isolation)',
 	      ].join('\n'),

package/scripts/stack_daemon_cmd.integration.test.mjs

@@ -448,6 +448,43 @@ test('hstack stack daemon <name> start uses runtime server port when env port is
   );
 });
 
+test('hstack stack daemon <name> start uses explicit HAPPIER_SERVER_URL when env port and runtime port are missing', async (t) => {
+  const fixture = await createDaemonFixture(t, {
+    prefix: 'happy-stacks-stack-daemon-explicit-server-url-',
+    stackName: 'exp-test',
+    serverPort: 4101,
+  });
+
+  await writeDummyAuth({ cliHomeDir: fixture.stackCliHome });
+
+  const explicitPort = fixture.serverPort + 9;
+  const envPath = join(fixture.storageDir, fixture.stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await writeFile(
+    envPath,
+    [
+      `HAPPIER_STACK_REPO_DIR=${fixture.baseEnv.HAPPIER_STACK_WORKSPACE_DIR}/happier`,
+      `HAPPIER_STACK_CLI_HOME_DIR=${fixture.stackCliHome}`,
+      `HAPPIER_SERVER_URL=http://127.0.0.1:${explicitPort}`,
+      `HAPPIER_WEBAPP_URL=http://happier-exp-test.localhost:${explicitPort}`,
+      '',
+    ].join('\n'),
+    'utf-8'
+  );
+
+  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 uses explicit HAPPIER_SERVER_URL');
+
+  const logPath = join(fixture.stackCliHome, 'stub-daemon.log');
+  const logText = await readLogText(logPath);
+  assert.ok(
+    logText.includes(`server_url=http://127.0.0.1:${explicitPort}`),
+    `expected daemon env to target explicit HAPPIER_SERVER_URL port ${explicitPort}\n${logText}`
+  );
+});
+
 test('hstack stack auth <name> login --identity=<name> --print prints identity-scoped HAPPIER_HOME_DIR', async (t) => {
   const fixture = await createDaemonFixture(t, {
     prefix: 'happier-stack-auth-identity-',

package/scripts/stack_happy_cmd.integration.test.mjs

@@ -25,6 +25,7 @@ async function writeStubHappyCli({ cliDir, message }) {
     [
       `console.log(JSON.stringify({`,
       `  message: ${JSON.stringify(message)},`,
+      `  args: process.argv.slice(2),`,
       `  stack: process.env.HAPPIER_STACK_STACK || null,`,
       `  envFile: process.env.HAPPIER_STACK_ENV_FILE || null,`,
       `  homeDir: process.env.HAPPIER_HOME_DIR || null,`,
@@ -261,3 +262,38 @@ test('hstack stack <name> happier ... stack-name-first shorthand works', async (
   assert.equal(out.message, 'name-first');
   assert.equal(out.stack, fixture.stackName);
 });
+
+test('hstack stack bug-report <name> forwards bug-report command under stack env', async (t) => {
+  const fixture = await createHappyStackFixture(t, {
+    prefix: 'happier-stack-stack-bug-report-',
+    message: 'bug-report-alias',
+    serverPort: 4099,
+  });
+
+  const res = await runNodeCapture(
+    [
+      join(rootDir, 'bin', 'hstack.mjs'),
+      'stack',
+      'bug-report',
+      fixture.stackName,
+      '--',
+      '--title',
+      'CLI bug',
+      '--summary',
+      'summary',
+      '--current-behavior',
+      'current',
+      '--expected-behavior',
+      'expected',
+      '--accept-privacy-notice',
+      '--no-include-diagnostics',
+    ],
+    { cwd: rootDir, env: fixture.baseEnv }
+  );
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const out = JSON.parse(res.stdout.trim());
+  assert.equal(out.message, 'bug-report-alias');
+  assert.equal(out.stack, fixture.stackName);
+  assert.equal(out.args[0], 'bug-report');
+});

package/scripts/stack_pr_help_cmd.test.mjs

@@ -0,0 +1,38 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { join } from 'node:path';
+
+import { getStackRootFromMeta, hstackBinPath, runNodeCapture } from './testkit/auth_testkit.mjs';
+
+test('hstack stack pr --help surfaces --reuse (supported flag)', async () => {
+  const rootDir = getStackRootFromMeta(import.meta.url);
+
+  const env = {
+    ...process.env,
+    // Prevent env.mjs from auto-loading a real machine stack env file (keeps the test hermetic).
+    HAPPIER_STACK_STACK: 'test-stack',
+    HAPPIER_STACK_ENV_FILE: join(rootDir, 'scripts', 'nonexistent-env'),
+  };
+
+  const res = await runNodeCapture([hstackBinPath(rootDir), 'stack', 'pr', '--help'], { cwd: rootDir, env });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstderr:\n${res.stderr}\nstdout:\n${res.stdout}`);
+  assert.match(res.stdout, /--reuse/, `expected stack pr help to include --reuse\nstdout:\n${res.stdout}`);
+});
+
+test('hstack stack --help shows --reuse on the stack pr usage line', async () => {
+  const rootDir = getStackRootFromMeta(import.meta.url);
+
+  const env = {
+    ...process.env,
+    HAPPIER_STACK_STACK: 'test-stack',
+    HAPPIER_STACK_ENV_FILE: join(rootDir, 'scripts', 'nonexistent-env'),
+  };
+
+  const res = await runNodeCapture([hstackBinPath(rootDir), 'stack', '--help'], { cwd: rootDir, env });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstderr:\n${res.stderr}\nstdout:\n${res.stdout}`);
+  assert.match(
+    res.stdout,
+    /hstack stack pr[^\n]*--reuse\b/,
+    `expected stack root help to include --reuse on the stack pr usage line\nstdout:\n${res.stdout}`
+  );
+});

package/scripts/stop.mjs

@@ -57,7 +57,7 @@ async function listAllStackNames() {
 async function main() {
   const rootDir = getRootDir(import.meta.url);
   const argv = process.argv.slice(2);
-  const { flags, kv } = parseArgs(argv);
+  const { flags, kv: argsKv } = parseArgs(argv);
   const json = wantsJson(argv, { flags });
 
   if (wantsHelp(argv, { flags })) {
@@ -65,7 +65,7 @@ async function main() {
     return;
   }
 
-  const exceptStacks = new Set(parseCsv(kv.get('--except-stacks')));
+  const exceptStacks = new Set(parseCsv(argsKv.get('--except-stacks')));
   const yes = flags.has('--yes');
   const aggressive = flags.has('--aggressive');
   const sweepOwned = flags.has('--sweep-owned');
@@ -187,4 +187,3 @@ main().catch((err) => {
   console.error('[stop] failed:', err);
   process.exit(1);
 });
-

package/scripts/utils/auth/credentials_paths.mjs

@@ -8,12 +8,12 @@ function normalizeServerUrl(url) {
   return String(url ?? '').trim().replace(/\/+$/, '');
 }
 
-function sanitizeServerIdForFilesystem(raw, fallback = 'cloud') {
+function sanitizeServerIdForFilesystem(raw, fallback = 'default') {
   const value = String(raw ?? '').trim();
-  if (!value) return String(fallback ?? '').trim() || 'cloud';
-  if (value === '.' || value === '..') return String(fallback ?? '').trim() || 'cloud';
-  if (value.includes('/') || value.includes('\\')) return String(fallback ?? '').trim() || 'cloud';
-  if (!SERVER_ID_SAFE_RE.test(value)) return String(fallback ?? '').trim() || 'cloud';
+  if (!value) return String(fallback ?? '').trim() || 'default';
+  if (value === '.' || value === '..') return String(fallback ?? '').trim() || 'default';
+  if (value.includes('/') || value.includes('\\')) return String(fallback ?? '').trim() || 'default';
+  if (!SERVER_ID_SAFE_RE.test(value)) return String(fallback ?? '').trim() || 'default';
   return value;
 }
 
@@ -46,8 +46,8 @@ export function resolveStackCredentialPaths({ cliHomeDir, serverUrl = '', env =
   const legacyPath = join(home, 'access.key');
   const normalizedServerUrl = normalizeServerUrl(serverUrl);
   const urlHashServerId = sanitizeServerIdForFilesystem(
-    normalizedServerUrl ? deriveServerIdFromUrl(normalizedServerUrl) : 'cloud',
-    'cloud'
+    normalizedServerUrl ? deriveServerIdFromUrl(normalizedServerUrl) : 'default',
+    'default'
   );
   const overrideServerId = resolveActiveServerIdOverride(env);
   const activeServerId = overrideServerId || urlHashServerId;
@@ -71,8 +71,8 @@ export function resolveStackDaemonStatePaths({ cliHomeDir, serverUrl = '', env =
   const home = requireCliHomeDir(cliHomeDir);
   const normalizedServerUrl = normalizeServerUrl(serverUrl);
   const urlHashServerId = sanitizeServerIdForFilesystem(
-    normalizedServerUrl ? deriveServerIdFromUrl(normalizedServerUrl) : 'cloud',
-    'cloud'
+    normalizedServerUrl ? deriveServerIdFromUrl(normalizedServerUrl) : 'default',
+    'default'
   );
   const overrideServerId = resolveActiveServerIdOverride(env);
   const activeServerId = overrideServerId || urlHashServerId;

package/scripts/utils/auth/credentials_paths.test.mjs

@@ -22,6 +22,14 @@ test('resolveStackCredentialPaths returns legacy + server-scoped paths', async (
   assert.deepEqual(out.paths, [out.serverScopedPath, out.legacyPath]);
 });
 
+test('resolveStackCredentialPaths uses a neutral default server id when serverUrl is empty', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'happy-stacks-cred-paths-'));
+  const out = resolveStackCredentialPaths({ cliHomeDir: dir, serverUrl: '' });
+  assert.equal(out.urlHashServerId, 'default');
+  assert.equal(out.activeServerId, 'default');
+  assert.ok(out.serverScopedPath.endsWith('/servers/default/access.key'));
+});
+
 test('findExistingStackCredentialPath prefers server-scoped credentials', async () => {
   const dir = await mkdtemp(join(tmpdir(), 'happy-stacks-cred-paths-'));
   const serverUrl = 'http://127.0.0.1:3009';

package/scripts/utils/auth/orchestrated_stack_auth_flow.mjs

@@ -19,15 +19,76 @@ function appendCauseText(baseMessage, cause) {
   return `${msg}\n\n[auth] Cause: ${c}`;
 }
 
+async function readTextWithTimeout(path, { timeoutMs = 1200 } = {}) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const res = await fetch(path, { signal: controller.signal });
+    clearTimeout(timer);
+    return { ok: res.ok, status: res.status };
+  } catch (error) {
+    return { ok: false, status: 0, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function formatPidStatus(label, pidRaw) {
+  const pid = Number(pidRaw);
+  if (!Number.isFinite(pid) || pid <= 1) return `[auth] ${label}: unavailable`;
+  return `[auth] ${label}: ${pid} (${isPidAlive(pid) ? 'alive' : 'stale/dead'})`;
+}
+
+function formatLogPath(label, logPath) {
+  const p = String(logPath ?? '').trim();
+  return p ? `[auth] ${label}: ${p}` : `[auth] ${label}: unavailable`;
+}
+
+async function appendRuntimeHealthDiagnostics(message, stackName) {
+  const name = String(stackName ?? '').trim() || 'main';
+  const statePath = getStackRuntimeStatePath(name);
+
+  const state = await readStackRuntimeStateFile(statePath).catch(() => null);
+  if (!state || typeof state !== 'object') {
+    return `${message}\n\n[auth] Stack runtime state unavailable: ${statePath}`;
+  }
+
+  const serverPort = Number(state?.ports?.server);
+  let serverHealth = 'not configured';
+  if (Number.isFinite(serverPort) && serverPort > 0) {
+    const probe = await readTextWithTimeout(`http://127.0.0.1:${serverPort}/health`, { timeoutMs: 1200 });
+    if (probe.ok) {
+      serverHealth = `HTTP ${probe.status}`;
+    } else if (probe.error) {
+      serverHealth = probe.error;
+    } else {
+      serverHealth = `HTTP ${probe.status}`;
+    }
+  }
+
+  const runtimeSummary = [
+    `[auth] Stack runtime path: ${statePath}`,
+    formatPidStatus('ownerPid', state?.ownerPid),
+    formatPidStatus('serverPid', state?.processes?.serverPid),
+    formatPidStatus('expoPid', state?.processes?.expoPid),
+    formatPidStatus('expoTailscaleForwarderPid', state?.processes?.expoTailscaleForwarderPid),
+    `[auth] server port: ${Number.isFinite(serverPort) && serverPort > 0 ? serverPort : 'unconfigured'}`,
+    `[auth] server health: ${serverHealth}`,
+    formatLogPath('runner log', state?.logs?.runner),
+    formatLogPath('cli log', state?.logs?.cli),
+  ].join('\n');
+
+  return `${String(message ?? '').trim()}\n\n${runtimeSummary}`;
+}
+
 async function appendRunnerLogTailDiagnostics({ message, stackName, lines = 140 }) {
   const base = String(message ?? '').trim();
   const logPath = await resolveRunnerLogPathFromRuntime({ stackName, waitMs: 1000, pollMs: 100 }).catch(() => '');
-  if (!logPath) return base;
+  const withState = await appendRuntimeHealthDiagnostics(base, stackName).catch(() => base);
+  if (!logPath) return withState;
   const tail = await readLastLines(logPath, lines).catch(() => null);
   if (!tail || !String(tail).trim()) {
-    return `${base}\n\n[auth] Stack runner log: ${logPath}`;
+    return `${withState}\n\n[auth] Stack runner log: ${logPath}`;
   }
-  return `${base}\n\n[auth] Stack runner log: ${logPath}\n\n[auth] Last runner log lines:\n${String(tail).trimEnd()}`;
+  return `${withState}\n\n[auth] Stack runner log: ${logPath}\n\n[auth] Last runner log lines:\n${String(tail).trimEnd()}`;
 }
 
 async function tryStartStackUiInBackgroundForAuth({ rootDir, stackName, env = process.env } = {}) {

package/scripts/utils/auth/stable_scope_id.mjs

@@ -50,7 +50,7 @@ export function buildStackStableScopeId({ stackName = 'main', cliIdentity = 'def
   if (isScopeIdSafe(compact)) return compact;
 
   const fallback = `stack_${hash}`;
-  return isScopeIdSafe(fallback) ? fallback : 'cloud';
+  return isScopeIdSafe(fallback) ? fallback : 'stack-default';
 }
 
 export function isStableScopeDisabled(env = process.env) {