@happier-dev/stack 0.1.0-preview.74.1

package/scripts/stack/stack_info_snapshot.mjs

@@ -0,0 +1,167 @@
+import { parseEnvToObject } from '../utils/env/dotenv.mjs';
+import { getComponentDir, resolveStackEnvPath } from '../utils/paths/paths.mjs';
+import { getEnvValueAny } from '../utils/env/values.mjs';
+import { resolveLocalhostHost, preferStackLocalhostUrl } from '../utils/paths/localhost_host.mjs';
+import { worktreeSpecFromDir } from '../utils/git/worktrees.mjs';
+import { getStackRuntimeStatePath, isPidAlive, readStackRuntimeStateFile } from '../utils/stack/runtime_state.mjs';
+import { isTcpPortFree } from '../utils/net/ports.mjs';
+import { readTextOrEmpty } from '../utils/fs/ops.mjs';
+import { resolveDefaultRepoEnv } from './stack_environment.mjs';
+
+const readExistingEnv = readTextOrEmpty;
+
+export async function readStackInfoSnapshot({ rootDir, stackName }) {
+  const baseDir = resolveStackEnvPath(stackName).baseDir;
+  const envPath = resolveStackEnvPath(stackName).envPath;
+  const envRaw = await readExistingEnv(envPath);
+  const stackEnv = envRaw ? parseEnvToObject(envRaw) : {};
+  const runtimeStatePath = getStackRuntimeStatePath(stackName);
+  const runtimeState = await readStackRuntimeStateFile(runtimeStatePath);
+
+  const serverComponent = getEnvValueAny(stackEnv, ['HAPPIER_STACK_SERVER_COMPONENT']) || 'happier-server-light';
+  const stackRemote = getEnvValueAny(stackEnv, ['HAPPIER_STACK_STACK_REMOTE']) || 'upstream';
+
+  const pinnedServerPortRaw = getEnvValueAny(stackEnv, ['HAPPIER_STACK_SERVER_PORT']);
+  const pinnedServerPort = pinnedServerPortRaw ? Number(pinnedServerPortRaw) : null;
+
+  const runtimePorts = runtimeState?.ports && typeof runtimeState.ports === 'object' ? runtimeState.ports : {};
+  const serverPort =
+    Number.isFinite(pinnedServerPort) && pinnedServerPort > 0
+      ? pinnedServerPort
+      : Number(runtimePorts?.server) > 0
+        ? Number(runtimePorts.server)
+        : null;
+  const backendPort = Number(runtimePorts?.backend) > 0 ? Number(runtimePorts.backend) : null;
+  const uiPort =
+    runtimeState?.expo && typeof runtimeState.expo === 'object' && Number(runtimeState.expo.webPort) > 0
+      ? Number(runtimeState.expo.webPort)
+      : null;
+  const mobilePort =
+    runtimeState?.expo && typeof runtimeState.expo === 'object' && Number(runtimeState.expo.mobilePort) > 0
+      ? Number(runtimeState.expo.mobilePort)
+      : null;
+  const ownerPid = Number(runtimeState?.ownerPid);
+  const serverPid = Number(runtimeState?.processes?.serverPid);
+  const expoPid = Number(runtimeState?.processes?.expoPid);
+  const expoTailscaleForwarderPid = Number(runtimeState?.processes?.expoTailscaleForwarderPid);
+
+  const ownerAlive = Number.isFinite(ownerPid) && ownerPid > 1 ? isPidAlive(ownerPid) : false;
+  const serverPidAlive = Number.isFinite(serverPid) && serverPid > 1 ? isPidAlive(serverPid) : false;
+  const expoPidAlive = Number.isFinite(expoPid) && expoPid > 1 ? isPidAlive(expoPid) : false;
+  const expoForwarderAlive =
+    Number.isFinite(expoTailscaleForwarderPid) && expoTailscaleForwarderPid > 1
+      ? isPidAlive(expoTailscaleForwarderPid)
+      : false;
+
+  const serverPortListening =
+    Number.isFinite(serverPort) && serverPort > 0
+      ? !(await isTcpPortFree(serverPort, { host: '127.0.0.1' }).catch(() => true))
+      : false;
+  const uiPortListening =
+    Number.isFinite(uiPort) && uiPort > 0
+      ? !(await isTcpPortFree(uiPort, { host: '127.0.0.1' }).catch(() => true))
+      : false;
+
+  const serverRunning =
+    Number.isFinite(serverPort) && serverPort > 0
+      ? serverPortListening
+      : serverPidAlive;
+  const uiRunning =
+    Number.isFinite(uiPort) && uiPort > 0
+      ? uiPortListening
+      : expoPidAlive;
+  const candidateRuntimePids = [ownerPid, serverPid, expoPid, expoTailscaleForwarderPid]
+    .filter((pid) => Number.isFinite(pid) && pid > 1);
+  const runningPid = candidateRuntimePids.find((pid) => isPidAlive(pid)) ?? null;
+  const running = ownerAlive || serverRunning || uiRunning || serverPidAlive || expoPidAlive || expoForwarderAlive;
+
+  const healthIssues = [];
+  if (Number.isFinite(serverPort) && serverPort > 0 && !serverRunning) {
+    healthIssues.push('server_down');
+  }
+  if (Number.isFinite(uiPort) && uiPort > 0 && !uiRunning) {
+    healthIssues.push('ui_down');
+  }
+  const healthStatus = !running ? 'stopped' : healthIssues.length > 0 ? 'degraded' : 'healthy';
+
+  const host = resolveLocalhostHost({ stackMode: true, stackName });
+  const internalServerUrl = serverPort ? `http://127.0.0.1:${serverPort}` : null;
+  const uiUrl = uiPort ? `http://${host}:${uiPort}` : null;
+  const mobileUrl = mobilePort ? await preferStackLocalhostUrl(`http://localhost:${mobilePort}`, { stackName }) : null;
+
+  const repoDir = getEnvValueAny(stackEnv, ['HAPPIER_STACK_REPO_DIR']) || resolveDefaultRepoEnv({ rootDir }).HAPPIER_STACK_REPO_DIR;
+  const repoWorktreeSpec = repoDir ? worktreeSpecFromDir({ rootDir, component: 'happier-ui', dir: repoDir }) || null : null;
+  const dirs = {
+    repoDir,
+    uiDir: getComponentDir(rootDir, 'happier-ui', { ...process.env, ...stackEnv }),
+    cliDir: getComponentDir(rootDir, 'happier-cli', { ...process.env, ...stackEnv }),
+    serverDir: getComponentDir(rootDir, serverComponent, { ...process.env, ...stackEnv }),
+  };
+
+  return {
+    ok: true,
+    stackName,
+    baseDir,
+    envPath,
+    runtimeStatePath,
+    serverComponent,
+    stackRemote,
+    pinned: {
+      serverPort: Number.isFinite(pinnedServerPort) && pinnedServerPort > 0 ? pinnedServerPort : null,
+    },
+    runtime: {
+      script: typeof runtimeState?.script === 'string' ? runtimeState.script : null,
+      ownerPid: Number.isFinite(ownerPid) && ownerPid > 1 ? ownerPid : null,
+      runningPid: Number.isFinite(runningPid) && runningPid > 1 ? runningPid : null,
+      running,
+      components: {
+        owner: {
+          pid: Number.isFinite(ownerPid) && ownerPid > 1 ? ownerPid : null,
+          running: ownerAlive,
+        },
+        server: {
+          pid: Number.isFinite(serverPid) && serverPid > 1 ? serverPid : null,
+          running: serverRunning,
+          pidAlive: serverPidAlive,
+          portListening: serverPortListening,
+        },
+        ui: {
+          pid: Number.isFinite(expoPid) && expoPid > 1 ? expoPid : null,
+          running: uiRunning,
+          pidAlive: expoPidAlive,
+          portListening: uiPortListening,
+        },
+        expoTailscaleForwarder: {
+          pid: Number.isFinite(expoTailscaleForwarderPid) && expoTailscaleForwarderPid > 1 ? expoTailscaleForwarderPid : null,
+          running: expoForwarderAlive,
+        },
+      },
+      health: {
+        status: healthStatus,
+        issues: healthIssues,
+      },
+      ports: runtimePorts,
+      expo: runtimeState?.expo ?? null,
+      processes: runtimeState?.processes ?? null,
+      startedAt: runtimeState?.startedAt ?? null,
+      updatedAt: runtimeState?.updatedAt ?? null,
+    },
+    urls: {
+      host,
+      internalServerUrl,
+      uiUrl,
+      mobileUrl,
+    },
+    ports: {
+      server: serverPort,
+      backend: backendPort,
+      ui: uiPort,
+      mobile: mobilePort,
+    },
+    repo: {
+      dir: repoDir,
+      worktreeSpec: repoWorktreeSpec,
+    },
+    dirs,
+  };
+}

package/scripts/stack/stack_mobile_install_command.mjs

@@ -0,0 +1,61 @@
+import { parseArgs } from '../utils/cli/args.mjs';
+import { printResult, wantsJson } from '../utils/cli/cli.mjs';
+import { parseEnvToObject } from '../utils/env/dotenv.mjs';
+import { ensureEnvFileUpdated } from '../utils/env/env_file.mjs';
+import { readTextOrEmpty } from '../utils/fs/ops.mjs';
+import { resolveStackEnvPath } from '../utils/paths/paths.mjs';
+import { defaultStackReleaseIdentity } from '../utils/mobile/identifiers.mjs';
+
+import { runStackScriptWithStackEnv } from './run_script_with_stack_env.mjs';
+
+export async function runStackMobileInstallCommand({ rootDir, stackName, passthrough, json }) {
+  const { flags: mobileFlags, kv: mobileKv } = parseArgs(passthrough);
+  const device = (mobileKv.get('--device') ?? '').toString();
+  const name = (mobileKv.get('--name') ?? mobileKv.get('--app-name') ?? '').toString().trim();
+  const jsonOut = wantsJson(passthrough, { flags: mobileFlags }) || json;
+
+  const envPath = resolveStackEnvPath(stackName).envPath;
+  const existingRaw = await readTextOrEmpty(envPath);
+  const existing = parseEnvToObject(existingRaw);
+  const priorName = (existing.HAPPIER_STACK_MOBILE_RELEASE_IOS_APP_NAME ?? '').toString().trim();
+  const identity = defaultStackReleaseIdentity({
+    stackName,
+    user: process.env.USER ?? process.env.USERNAME ?? 'user',
+    appName: name || priorName || null,
+  });
+
+  await ensureEnvFileUpdated({
+    envPath,
+    updates: [
+      { key: 'HAPPIER_STACK_MOBILE_RELEASE_IOS_APP_NAME', value: identity.iosAppName },
+      { key: 'HAPPIER_STACK_MOBILE_RELEASE_IOS_BUNDLE_ID', value: identity.iosBundleId },
+      { key: 'HAPPIER_STACK_MOBILE_RELEASE_SCHEME', value: identity.scheme },
+    ],
+  });
+
+  const args = [
+    '--app-env=production',
+    `--ios-app-name=${identity.iosAppName}`,
+    `--ios-bundle-id=${identity.iosBundleId}`,
+    `--scheme=${identity.scheme}`,
+    '--prebuild',
+    '--run-ios',
+    '--configuration=Release',
+    '--no-metro',
+    ...(device ? [`--device=${device}`] : []),
+  ];
+
+  await runStackScriptWithStackEnv({ rootDir, stackName, scriptPath: 'mobile.mjs', args });
+
+  if (jsonOut) {
+    printResult({
+      json: true,
+      data: {
+        ok: true,
+        stackName,
+        installed: true,
+        identity,
+      },
+    });
+  }
+}

package/scripts/stack/stack_resume_command.mjs

@@ -0,0 +1,76 @@
+import { join } from 'node:path';
+
+import { printResult } from '../utils/cli/cli.mjs';
+import { getComponentDir } from '../utils/paths/paths.mjs';
+import { run, runCapture } from '../utils/proc/proc.mjs';
+
+import { withStackEnv } from './stack_environment.mjs';
+
+function supportsDaemonResume(helpText) {
+  const normalized = String(helpText ?? '').toLowerCase();
+  return /\bdaemon\s+resume\b/.test(normalized);
+}
+
+export async function runStackResumeCommand({ rootDir, stackName, passthrough, json }) {
+  const sessionIds = passthrough.filter((arg) => arg && arg !== '--' && !arg.startsWith('--'));
+  if (sessionIds.length === 0) {
+    printResult({
+      json,
+      data: { ok: false, error: 'missing_session_ids' },
+      text: [
+        '[stack] usage:',
+        '  hstack stack resume <name> <sessionId...>',
+      ].join('\n'),
+    });
+    process.exit(1);
+  }
+
+  const result = await withStackEnv({
+    stackName,
+    fn: async ({ env }) => {
+      const cliDir = getComponentDir(rootDir, 'happier-cli', env);
+      const happierBin = join(cliDir, 'bin', 'happier.mjs');
+
+      let daemonHelpText = '';
+      try {
+        daemonHelpText = await runCapture(process.execPath, [happierBin, 'daemon', '--help'], { cwd: rootDir, env });
+      } catch {
+        daemonHelpText = '';
+      }
+
+      if (!supportsDaemonResume(daemonHelpText)) {
+        return { ok: false, error: 'resume_not_supported' };
+      }
+
+      const out = await run(process.execPath, [happierBin, 'daemon', 'resume', ...sessionIds], { cwd: rootDir, env });
+      return { ok: true, out };
+    },
+  });
+
+  if (!result?.ok) {
+    printResult({
+      json,
+      data: { ok: false, error: 'resume_not_supported', resumed: [] },
+      text: [
+        '[stack] resume_not_supported',
+        'Current happier-cli does not support `happier daemon resume`.',
+        'Use the app UI to resume inactive sessions, or update to a compatible CLI/hstack pair.',
+      ].join('\n'),
+    });
+    process.exit(1);
+  }
+
+  if (json) {
+    printResult({ json, data: { ok: true, resumed: sessionIds, out: result.out } });
+  } else {
+    const outText = String(result.out ?? '').trim();
+    printResult({
+      json,
+      data: { ok: true, resumed: sessionIds, out: result.out },
+      text: [
+        `[stack] resumed ${sessionIds.length} session(s): ${sessionIds.join(', ')}`,
+        outText ? outText : '',
+      ].filter(Boolean).join('\n'),
+    });
+  }
+}

package/scripts/stack/stack_stop_command.mjs

@@ -0,0 +1,34 @@
+import { parseArgs } from '../utils/cli/args.mjs';
+import { printResult } from '../utils/cli/cli.mjs';
+import { resolveStackEnvPath } from '../utils/paths/paths.mjs';
+import { stopStackWithEnv } from '../utils/stack/stop.mjs';
+
+import { withStackEnv } from './stack_environment.mjs';
+
+export async function runStackStopCommand({ rootDir, stackName, passthrough, json }) {
+  const { flags: stopFlags } = parseArgs(passthrough);
+  const noDocker = stopFlags.has('--no-docker');
+  const aggressive = stopFlags.has('--aggressive');
+  const sweepOwned = stopFlags.has('--sweep-owned');
+  const baseDir = resolveStackEnvPath(stackName).baseDir;
+
+  const out = await withStackEnv({
+    stackName,
+    fn: async ({ env }) => {
+      return await stopStackWithEnv({
+        rootDir,
+        stackName,
+        baseDir,
+        env,
+        json,
+        noDocker,
+        aggressive,
+        sweepOwned,
+      });
+    },
+  });
+
+  if (json) {
+    printResult({ json, data: { ok: true, stopped: out } });
+  }
+}

package/scripts/stack/stack_workspace_command.mjs

@@ -0,0 +1,83 @@
+import { printResult } from '../utils/cli/cli.mjs';
+import { isCursorInstalled, openWorkspaceInEditor, writeStackCodeWorkspace } from '../utils/stack/editor_workspace.mjs';
+
+function resolveWorkspaceCommandOptions({ flags }) {
+  return {
+    includeStackDir: !flags.has('--no-stack-dir'),
+    includeAllComponents: flags.has('--include-all-components'),
+    includeCliHome: flags.has('--include-cli-home'),
+  };
+}
+
+async function runStackEditorWorkspaceCommand({
+  rootDir,
+  stackName,
+  json,
+  editor,
+  includeStackDir,
+  includeAllComponents,
+  includeCliHome,
+}) {
+  const ws = await writeStackCodeWorkspace({
+    rootDir,
+    stackName,
+    includeStackDir,
+    includeAllComponents,
+    includeCliHome,
+  });
+
+  if (json) {
+    printResult({
+      json,
+      data: {
+        ok: true,
+        stackName,
+        editor,
+        ...ws,
+      },
+    });
+    return;
+  }
+
+  await openWorkspaceInEditor({ rootDir, editor, workspacePath: ws.workspacePath });
+  console.log(`[stack] opened ${editor === 'code' ? 'VS Code' : 'Cursor'} workspace for "${stackName}": ${ws.workspacePath}`);
+}
+
+export async function runStackWorkspaceCommand({ command, rootDir, stackName, json, flags }) {
+  const options = resolveWorkspaceCommandOptions({ flags });
+  if (command === 'code') {
+    await runStackEditorWorkspaceCommand({
+      rootDir,
+      stackName,
+      json,
+      editor: 'code',
+      ...options,
+    });
+    return;
+  }
+
+  if (command === 'cursor') {
+    await runStackEditorWorkspaceCommand({
+      rootDir,
+      stackName,
+      json,
+      editor: 'cursor',
+      ...options,
+    });
+    return;
+  }
+
+  if (command === 'open') {
+    const editor = (await isCursorInstalled({ cwd: rootDir, env: process.env })) ? 'cursor' : 'code';
+    await runStackEditorWorkspaceCommand({
+      rootDir,
+      stackName,
+      json,
+      editor,
+      ...options,
+    });
+    return;
+  }
+
+  throw new Error(`[stack] unsupported workspace command: ${command}`);
+}

package/scripts/stack/transient_repo_overrides.mjs

@@ -0,0 +1,29 @@
+import { existsSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+import { coerceHappyMonorepoRootFromPath, getRepoDir, getWorkspaceDir } from '../utils/paths/paths.mjs';
+import { resolveComponentSpecToDir } from '../utils/git/worktrees.mjs';
+
+export function resolveTransientRepoOverrides({ rootDir, kv }) {
+  const raw = (kv.get('--repo') ?? kv.get('--repo-dir') ?? '').toString().trim();
+  if (!raw) return {};
+
+  let resolved = '';
+  if (raw === 'default' || raw === 'main') {
+    resolved = getRepoDir(rootDir, { ...process.env, HAPPIER_STACK_REPO_DIR: '' });
+  } else if (raw === 'active') {
+    resolved = getRepoDir(rootDir, process.env);
+  } else {
+    const dir = resolveComponentSpecToDir({ rootDir, component: 'happier-ui', spec: raw });
+    const abs = dir ? resolve(rootDir, dir) : isAbsolute(raw) ? raw : resolve(getWorkspaceDir(rootDir), raw);
+    resolved = coerceHappyMonorepoRootFromPath(abs) || abs;
+  }
+
+  if (!resolved || !existsSync(resolved)) {
+    throw new Error(`[stack] --repo points to a missing checkout: ${resolved || '(empty)'}`);
+  }
+  const monoRoot = coerceHappyMonorepoRootFromPath(resolved);
+  if (!monoRoot) {
+    throw new Error(`[stack] --repo is not a Happier monorepo root: ${resolved}`);
+  }
+  return { HAPPIER_STACK_REPO_DIR: monoRoot };
+}