happy-stacks 0.2.0 → 0.4.0

package/scripts/utils/review/runners/coderabbit.mjs

@@ -0,0 +1,19 @@
+import { runCaptureResult } from '../../proc/proc.mjs';
+
+export async function runCodeRabbitReview({ repoDir, baseRef, env }) {
+  const args = [
+    'review',
+    '--plain',
+    '--no-color',
+    '--type',
+    'all',
+    '--cwd',
+    repoDir,
+  ];
+  if (baseRef) {
+    args.push('--base', baseRef);
+  }
+  const res = await runCaptureResult('coderabbit', args, { cwd: repoDir, env });
+  return { ...res, stdout: res.out, stderr: res.err };
+}
+

package/scripts/utils/review/runners/codex.mjs

@@ -0,0 +1,51 @@
+import { runCaptureResult } from '../../proc/proc.mjs';
+
+export function extractCodexReviewFromJsonl(jsonlText) {
+  const lines = String(jsonlText ?? '')
+    .split('\n')
+    .map((l) => l.trim())
+    .filter(Boolean);
+
+  // JSONL events typically look like: { "type": "...", "payload": {...} } or similar.
+  // We keep this resilient by searching for keys matching the exec output format.
+  for (const line of lines) {
+    let obj = null;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const msg = obj?.msg ?? obj?.payload ?? obj;
+    // We’ve observed EventMsg names like "ExitedReviewMode" in Codex protocol events.
+    // Accept several shapes:
+    // - { msg: { ExitedReviewMode: { review_output: {...} } } }
+    // - { type: "ExitedReviewMode", review_output: {...} }
+    const exited =
+      msg?.ExitedReviewMode ??
+      (obj?.type === 'ExitedReviewMode' ? obj : null) ??
+      (msg?.type === 'ExitedReviewMode' ? msg : null);
+
+    const reviewOutput = exited?.review_output ?? exited?.reviewOutput ?? null;
+    if (reviewOutput) return reviewOutput;
+  }
+  return null;
+}
+
+export async function runCodexReview({ repoDir, baseRef, env, jsonMode }) {
+  const args = ['review', '--cd', repoDir, '--color=never'];
+
+  if (baseRef) {
+    args.push('--base', baseRef);
+  } else {
+    // Codex requires one of --uncommitted/--base/--commit/prompt; baseRef should exist in our flow.
+    args.push('--uncommitted');
+  }
+
+  if (jsonMode) {
+    args.push('--json');
+  }
+
+  const res = await runCaptureResult('codex', args, { cwd: repoDir, env });
+  return { ...res, stdout: res.out, stderr: res.err };
+}
+

package/scripts/utils/review/targets.mjs

@@ -0,0 +1,24 @@
+import { getComponentsDir, getComponentDir } from '../paths/paths.mjs';
+import { join } from 'node:path';
+
+export function isStackMode(env = process.env) {
+  const stack = String(env.HAPPY_STACKS_STACK ?? env.HAPPY_LOCAL_STACK ?? '').trim();
+  const envFile = String(env.HAPPY_STACKS_ENV_FILE ?? env.HAPPY_LOCAL_ENV_FILE ?? '').trim();
+  return Boolean(stack && envFile);
+}
+
+export function defaultComponentCheckoutDir(rootDir, component) {
+  return join(getComponentsDir(rootDir), component);
+}
+
+export function resolveDefaultStackReviewComponents({ rootDir, components }) {
+  const list = Array.isArray(components) ? components : [];
+  const out = [];
+  for (const c of list) {
+    const effective = getComponentDir(rootDir, c);
+    const def = defaultComponentCheckoutDir(rootDir, c);
+    if (effective !== def) out.push(c);
+  }
+  return out;
+}
+

package/scripts/utils/review/targets.test.mjs

@@ -0,0 +1,36 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { resolveDefaultStackReviewComponents } from './targets.mjs';
+
+test('resolveDefaultStackReviewComponents returns only non-default pinned components', () => {
+  const rootDir = '/tmp/hs-root';
+  const keys = [
+    'HAPPY_STACKS_WORKSPACE_DIR',
+    'HAPPY_STACKS_COMPONENT_DIR_HAPPY',
+    'HAPPY_STACKS_COMPONENT_DIR_HAPPY_SERVER_LIGHT',
+    'HAPPY_STACKS_COMPONENT_DIR_HAPPY_CLI',
+    'HAPPY_STACKS_COMPONENT_DIR_HAPPY_SERVER',
+  ];
+  const old = Object.fromEntries(keys.map((k) => [k, process.env[k]]));
+  try {
+    process.env.HAPPY_STACKS_WORKSPACE_DIR = '/tmp/hs-root';
+    // Default checkouts
+    process.env.HAPPY_STACKS_COMPONENT_DIR_HAPPY = '';
+    process.env.HAPPY_STACKS_COMPONENT_DIR_HAPPY_SERVER_LIGHT = '';
+    // Pinned overrides
+    process.env.HAPPY_STACKS_COMPONENT_DIR_HAPPY_CLI = '/tmp/custom/happy-cli';
+    process.env.HAPPY_STACKS_COMPONENT_DIR_HAPPY_SERVER = '/tmp/custom/happy-server';
+
+    const comps = resolveDefaultStackReviewComponents({
+      rootDir,
+      components: ['happy', 'happy-cli', 'happy-server-light', 'happy-server'],
+    });
+    assert.deepEqual(comps.sort(), ['happy-cli', 'happy-server'].sort());
+  } finally {
+    for (const k of keys) {
+      if (old[k] == null) delete process.env[k];
+      else process.env[k] = old[k];
+    }
+  }
+});
+

package/scripts/utils/sandbox/review_pr_sandbox.mjs

@@ -0,0 +1,106 @@
+import { existsSync } from 'node:fs';
+import { readFile, readdir, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { basename, join, resolve } from 'node:path';
+
+export const REVIEW_PR_MARKER_FILENAME = '.happy-stacks-sandbox-marker';
+export const REVIEW_PR_META_FILENAME = '.happy-stacks-review-pr.json';
+
+export function reviewPrSandboxPrefixBase(baseStackName) {
+  const base = String(baseStackName ?? '').trim() || 'pr';
+  // Keep prefix stable for listing/reuse; mkdtemp adds a random suffix.
+  return `happy-stacks-review-pr-${base}-`;
+}
+
+export function reviewPrSandboxPrefixPath(baseStackName) {
+  return join(tmpdir(), reviewPrSandboxPrefixBase(baseStackName));
+}
+
+async function readJsonBestEffort(path) {
+  try {
+    const raw = await readFile(path, 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export async function listReviewPrSandboxes({ baseStackName }) {
+  const prefixBase = reviewPrSandboxPrefixBase(baseStackName);
+  const root = tmpdir();
+  let entries = [];
+  try {
+    entries = await readdir(root, { withFileTypes: true });
+  } catch {
+    entries = [];
+  }
+
+  const out = [];
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    if (!e.name.startsWith(prefixBase)) continue;
+    const dir = resolve(join(root, e.name));
+    const markerPath = join(dir, REVIEW_PR_MARKER_FILENAME);
+    if (!existsSync(markerPath)) continue;
+
+    let markerOk = false;
+    try {
+      const marker = await readFile(markerPath, 'utf-8');
+      markerOk = marker.trim().startsWith('review-pr');
+    } catch {
+      markerOk = false;
+    }
+    if (!markerOk) continue;
+
+    const metaPath = join(dir, REVIEW_PR_META_FILENAME);
+    const meta = await readJsonBestEffort(metaPath);
+
+    let mtimeMs = 0;
+    try {
+      mtimeMs = (await stat(dir)).mtimeMs;
+    } catch {
+      mtimeMs = 0;
+    }
+
+    out.push({
+      dir,
+      name: basename(dir),
+      markerPath,
+      metaPath,
+      baseStackName: String(meta?.baseStackName ?? '').trim() || String(baseStackName ?? '').trim() || null,
+      stackName: String(meta?.stackName ?? '').trim() || null,
+      createdAtMs: typeof meta?.createdAtMs === 'number' ? meta.createdAtMs : null,
+      lastTouchedAtMs: Number.isFinite(mtimeMs) ? mtimeMs : null,
+    });
+  }
+
+  out.sort((a, b) => (b.lastTouchedAtMs ?? 0) - (a.lastTouchedAtMs ?? 0));
+  return out;
+}
+
+export async function writeReviewPrSandboxMeta({ sandboxDir, baseStackName, stackName, argv }) {
+  const dir = resolve(String(sandboxDir ?? '').trim());
+  const markerPath = join(dir, REVIEW_PR_MARKER_FILENAME);
+  const metaPath = join(dir, REVIEW_PR_META_FILENAME);
+
+  // Marker (for safe deletion) + meta (for reuse menu).
+  await writeFile(markerPath, 'review-pr\n', 'utf-8');
+  await writeFile(
+    metaPath,
+    JSON.stringify(
+      {
+        kind: 'review-pr',
+        createdAtMs: Date.now(),
+        baseStackName: String(baseStackName ?? '').trim() || null,
+        stackName: String(stackName ?? '').trim() || null,
+        argv: Array.isArray(argv) ? argv : null,
+      },
+      null,
+      2
+    ) + '\n',
+    'utf-8'
+  );
+
+  return { markerPath, metaPath };
+}
+

package/scripts/utils/{happy_server_infra.mjs → server/infra/happy_server_infra.mjs}

@@ -1,50 +1,18 @@
-import { randomBytes } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 
-import { parseDotenv } from './dotenv.mjs';
-import { ensureEnvFileUpdated } from './env_file.mjs';
-import { pickNextFreeTcpPort } from './ports.mjs';
-import { pmExecBin } from './pm.mjs';
-import { run, runCapture } from './proc.mjs';
-
-function base64Url(buf) {
-  return Buffer.from(buf)
-    .toString('base64')
-    .replaceAll('+', '-')
-    .replaceAll('/', '_')
-    .replaceAll('=', '');
-}
-
-function randomToken(lenBytes = 24) {
-  return base64Url(randomBytes(lenBytes));
-}
-
-function sanitizeDnsLabel(raw, { fallback = 'happy' } = {}) {
-  const s = String(raw ?? '')
-    .toLowerCase()
-    .replace(/[^a-z0-9-]+/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-+/, '')
-    .replace(/-+$/, '');
-  return s || fallback;
-}
+import { ensureEnvFileUpdated } from '../../env/env_file.mjs';
+import { readEnvObjectFromFile } from '../../env/read.mjs';
+import { sanitizeDnsLabel } from '../../net/dns.mjs';
+import { pickNextFreeTcpPort } from '../../net/ports.mjs';
+import { pmExecBin } from '../../proc/pm.mjs';
+import { run, runCapture } from '../../proc/proc.mjs';
+import { randomToken } from '../../crypto/tokens.mjs';
+import { coercePort, INFRA_RESERVED_PORT_KEYS } from '../port.mjs';
 
-function coercePort(v) {
-  const n = typeof v === 'string' ? Number(v) : typeof v === 'number' ? v : NaN;
-  return Number.isFinite(n) && n > 0 ? n : null;
-}
-
-async function readEnvObject(envPath) {
-  try {
-    const raw = await readFile(envPath, 'utf-8');
-    return Object.fromEntries(parseDotenv(raw).entries());
-  } catch {
-    return {};
-  }
-}
+const readEnvObject = readEnvObjectFromFile;
 
 async function ensureTextFile({ path, generate }) {
   if (existsSync(path)) {
@@ -318,14 +286,7 @@ export async function ensureHappyServerManagedInfra({
   const reservedPorts = new Set();
 
   // Reserve known ports (if present) to avoid picking duplicates when auto-filling.
-  for (const key of [
-    'HAPPY_STACKS_SERVER_PORT',
-    'HAPPY_LOCAL_SERVER_PORT',
-    'HAPPY_STACKS_PG_PORT',
-    'HAPPY_STACKS_REDIS_PORT',
-    'HAPPY_STACKS_MINIO_PORT',
-    'HAPPY_STACKS_MINIO_CONSOLE_PORT',
-  ]) {
+  for (const key of INFRA_RESERVED_PORT_KEYS) {
     const p = coercePort(existingEnv[key] ?? env[key]);
     if (p) reservedPorts.add(p);
   }

package/scripts/utils/server/mobile_api_url.mjs

@@ -0,0 +1,61 @@
+import { pickLanIpv4 } from '../net/lan_ip.mjs';
+import { normalizeUrlNoTrailingSlash } from '../net/url.mjs';
+
+function resolveLanIp({ env = process.env } = {}) {
+  const raw = (env.HAPPY_STACKS_LAN_IP ?? env.HAPPY_LOCAL_LAN_IP ?? '').toString().trim();
+  return raw || pickLanIpv4() || '';
+}
+
+function isLocalHostName(hostname) {
+  const h = String(hostname ?? '').trim().toLowerCase();
+  if (!h) return false;
+  if (h === 'localhost' || h === '127.0.0.1' || h === '0.0.0.0') return true;
+  if (h.endsWith('.localhost')) return true;
+  return false;
+}
+
+/**
+ * For mobile devices, `localhost` and `*.localhost` are not reachable.
+ *
+ * This helper rewrites any local server URL to a LAN-reachable URL using the machine's LAN IPv4.
+ * It preserves protocol, port, and path/query.
+ *
+ * Notes:
+ * - If the URL is already non-local (e.g. Tailscale HTTPS), it is returned unchanged.
+ * - If LAN IP cannot be determined, it returns the original URL unchanged.
+ */
+export function resolveMobileReachableServerUrl({
+  env = process.env,
+  serverUrl,
+  serverPort,
+} = {}) {
+  const raw = String(serverUrl ?? '').trim();
+  const fallbackPort = Number(serverPort);
+  const fallback = Number.isFinite(fallbackPort) && fallbackPort > 0 ? `http://localhost:${fallbackPort}` : '';
+  const base = raw || fallback;
+  if (!base) return '';
+
+  let parsed;
+  try {
+    parsed = new URL(base);
+  } catch {
+    return base;
+  }
+
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    return base;
+  }
+
+  if (!isLocalHostName(parsed.hostname)) {
+    return normalizeUrlNoTrailingSlash(parsed.toString());
+  }
+
+  const lanIp = resolveLanIp({ env });
+  if (!lanIp) {
+    return normalizeUrlNoTrailingSlash(parsed.toString());
+  }
+
+  parsed.hostname = lanIp;
+  return normalizeUrlNoTrailingSlash(parsed.toString());
+}
+

package/scripts/utils/server/mobile_api_url.test.mjs

@@ -0,0 +1,41 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { resolveMobileReachableServerUrl } from './mobile_api_url.mjs';
+
+test('resolveMobileReachableServerUrl rewrites localhost to LAN IP (env override)', () => {
+  const out = resolveMobileReachableServerUrl({
+    env: { HAPPY_STACKS_LAN_IP: '192.168.0.50' },
+    serverUrl: 'http://localhost:3005',
+    serverPort: 3005,
+  });
+  assert.equal(out, 'http://192.168.0.50:3005');
+});
+
+test('resolveMobileReachableServerUrl rewrites *.localhost to LAN IP (env override)', () => {
+  const out = resolveMobileReachableServerUrl({
+    env: { HAPPY_STACKS_LAN_IP: '10.0.0.12' },
+    serverUrl: 'http://happy-exp1.localhost:3009/',
+    serverPort: 3009,
+  });
+  assert.equal(out, 'http://10.0.0.12:3009');
+});
+
+test('resolveMobileReachableServerUrl preserves path and query', () => {
+  const out = resolveMobileReachableServerUrl({
+    env: { HAPPY_STACKS_LAN_IP: '10.0.0.12' },
+    serverUrl: 'http://127.0.0.1:3005/api?x=1',
+    serverPort: 3005,
+  });
+  assert.equal(out, 'http://10.0.0.12:3005/api?x=1');
+});
+
+test('resolveMobileReachableServerUrl does not rewrite non-local URLs', () => {
+  const out = resolveMobileReachableServerUrl({
+    env: { HAPPY_STACKS_LAN_IP: '192.168.0.50' },
+    serverUrl: 'https://my-machine.tailnet.ts.net',
+    serverPort: 3005,
+  });
+  assert.equal(out, 'https://my-machine.tailnet.ts.net');
+});
+

package/scripts/utils/server/port.mjs

@@ -0,0 +1,68 @@
+import { readEnvValueFromFile } from '../env/read.mjs';
+
+export const STACK_RESERVED_PORT_KEYS = [
+  'HAPPY_STACKS_SERVER_PORT',
+  'HAPPY_LOCAL_SERVER_PORT',
+  'HAPPY_STACKS_HAPPY_SERVER_BACKEND_PORT',
+  'HAPPY_LOCAL_HAPPY_SERVER_BACKEND_PORT',
+  'HAPPY_STACKS_PG_PORT',
+  'HAPPY_STACKS_REDIS_PORT',
+  'HAPPY_STACKS_MINIO_PORT',
+  'HAPPY_STACKS_MINIO_CONSOLE_PORT',
+];
+
+export const INFRA_RESERVED_PORT_KEYS = [
+  'HAPPY_STACKS_SERVER_PORT',
+  'HAPPY_LOCAL_SERVER_PORT',
+  'HAPPY_STACKS_PG_PORT',
+  'HAPPY_STACKS_REDIS_PORT',
+  'HAPPY_STACKS_MINIO_PORT',
+  'HAPPY_STACKS_MINIO_CONSOLE_PORT',
+];
+
+export function coercePort(v) {
+  const s = String(v ?? '').trim();
+  if (!s) return null;
+  const n = Number(s);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+
+export function resolveServerPortFromEnv({ env = process.env, defaultPort = 3005 } = {}) {
+  const raw =
+    (env.HAPPY_STACKS_SERVER_PORT ?? '').toString().trim() ||
+    (env.HAPPY_LOCAL_SERVER_PORT ?? '').toString().trim() ||
+    '';
+  const n = raw ? Number(raw) : Number(defaultPort);
+  return Number.isFinite(n) && n > 0 ? n : Number(defaultPort);
+}
+
+export function listPortsFromEnvObject(env, keys) {
+  const obj = env && typeof env === 'object' ? env : {};
+  const list = Array.isArray(keys) ? keys : [];
+  const out = [];
+  for (const k of list) {
+    const p = coercePort(obj[k]);
+    if (p) out.push(p);
+  }
+  return out;
+}
+
+export async function readServerPortFromEnvFile(envPath, { defaultPort = 3005 } = {}) {
+  const v =
+    (await readEnvValueFromFile(envPath, 'HAPPY_STACKS_SERVER_PORT')) ||
+    (await readEnvValueFromFile(envPath, 'HAPPY_LOCAL_SERVER_PORT')) ||
+    '';
+  const n = v ? Number(String(v).trim()) : Number(defaultPort);
+  return Number.isFinite(n) && n > 0 ? n : Number(defaultPort);
+}
+
+// For stack env files, "missing" means "ephemeral stack" (no pinned port).
+export async function readPinnedServerPortFromEnvFile(envPath) {
+  const v =
+    (await readEnvValueFromFile(envPath, 'HAPPY_STACKS_SERVER_PORT')) ||
+    (await readEnvValueFromFile(envPath, 'HAPPY_LOCAL_SERVER_PORT')) ||
+    '';
+  const n = v ? Number(String(v).trim()) : NaN;
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+

package/scripts/utils/{server.mjs → server/server.mjs}

@@ -59,6 +59,18 @@ export async function isHappyServerRunning(baseUrl) {
   return true;
 }
 
+export async function waitForHappyHealthOk(baseUrl, { timeoutMs = 60_000, intervalMs = 300 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    // eslint-disable-next-line no-await-in-loop
+    const health = await fetchHappyHealth(baseUrl);
+    if (health.ok) return true;
+    // eslint-disable-next-line no-await-in-loop
+    await delay(intervalMs);
+  }
+  return false;
+}
+
 export async function waitForServerReady(url) {
   const deadline = Date.now() + 60_000;
   while (Date.now() < deadline) {

package/scripts/utils/server/urls.mjs

@@ -0,0 +1,101 @@
+import { existsSync, readFileSync } from 'node:fs';
+
+import { getStackName, resolveStackEnvPath } from '../paths/paths.mjs';
+import { preferStackLocalhostUrl } from '../paths/localhost_host.mjs';
+import { resolvePublicServerUrl } from '../../tailscale.mjs';
+import { resolveServerPortFromEnv } from './port.mjs';
+import { normalizeUrlNoTrailingSlash } from '../net/url.mjs';
+
+function stackEnvExplicitlySetsPublicUrl({ env, stackName }) {
+  try {
+    const envPath =
+      (env.HAPPY_STACKS_ENV_FILE ?? env.HAPPY_LOCAL_ENV_FILE ?? '').toString().trim() ||
+      resolveStackEnvPath(stackName).envPath;
+    if (!envPath || !existsSync(envPath)) return false;
+    const raw = readFileSync(envPath, 'utf-8');
+    return /^(HAPPY_STACKS_SERVER_URL|HAPPY_LOCAL_SERVER_URL)=/m.test(raw);
+  } catch {
+    return false;
+  }
+}
+
+function stackEnvExplicitlySetsWebappUrl({ env, stackName }) {
+  try {
+    const envPath =
+      (env.HAPPY_STACKS_ENV_FILE ?? env.HAPPY_LOCAL_ENV_FILE ?? '').toString().trim() ||
+      resolveStackEnvPath(stackName).envPath;
+    if (!envPath || !existsSync(envPath)) return false;
+    const raw = readFileSync(envPath, 'utf-8');
+    return /^HAPPY_WEBAPP_URL=/m.test(raw);
+  } catch {
+    return false;
+  }
+}
+
+export function getPublicServerUrlEnvOverride({ env = process.env, serverPort, stackName = null } = {}) {
+  const name =
+    (stackName ?? '').toString().trim() ||
+    (env.HAPPY_STACKS_STACK ?? env.HAPPY_LOCAL_STACK ?? '').toString().trim() ||
+    getStackName(env);
+  const defaultPublicUrl = `http://localhost:${serverPort}`;
+
+  let envPublicUrl =
+    (env.HAPPY_STACKS_SERVER_URL ?? env.HAPPY_LOCAL_SERVER_URL ?? '').toString().trim() || '';
+  envPublicUrl = normalizeUrlNoTrailingSlash(envPublicUrl);
+
+  // Safety: for non-main stacks, ignore a global SERVER_URL unless it was explicitly set in the stack env file.
+  if (name !== 'main' && envPublicUrl && !stackEnvExplicitlySetsPublicUrl({ env, stackName: name })) {
+    envPublicUrl = '';
+  }
+
+  return { defaultPublicUrl, envPublicUrl, publicServerUrl: envPublicUrl || defaultPublicUrl };
+}
+
+export function getWebappUrlEnvOverride({ env = process.env, stackName = null } = {}) {
+  const name =
+    (stackName ?? '').toString().trim() ||
+    (env.HAPPY_STACKS_STACK ?? env.HAPPY_LOCAL_STACK ?? '').toString().trim() ||
+    getStackName(env);
+
+  let envWebappUrl = (env.HAPPY_WEBAPP_URL ?? '').toString().trim() || '';
+
+  // Safety: for non-main stacks, ignore a global HAPPY_WEBAPP_URL unless it was explicitly set in the stack env file.
+  if (name !== 'main' && envWebappUrl && !stackEnvExplicitlySetsWebappUrl({ env, stackName: name })) {
+    envWebappUrl = '';
+  }
+
+  return { envWebappUrl };
+}
+
+export async function resolveServerUrls({ env = process.env, serverPort, allowEnable = true } = {}) {
+  const internalServerUrl = `http://127.0.0.1:${serverPort}`;
+  const stackName =
+    (env.HAPPY_STACKS_STACK ?? env.HAPPY_LOCAL_STACK ?? '').toString().trim() ||
+    getStackName(env);
+  const { defaultPublicUrl, envPublicUrl } = getPublicServerUrlEnvOverride({ env, serverPort });
+  const resolved = await resolvePublicServerUrl({
+    internalServerUrl,
+    defaultPublicUrl,
+    envPublicUrl,
+    allowEnable,
+    stackName,
+  });
+  const publicServerUrl = normalizeUrlNoTrailingSlash(
+    await preferStackLocalhostUrl(resolved.publicServerUrl, { stackName })
+  );
+  return {
+    internalServerUrl,
+    defaultPublicUrl,
+    envPublicUrl,
+    publicServerUrl,
+    publicServerUrlSource: resolved.source,
+  };
+}
+
+export function getInternalServerUrl({ env = process.env, defaultPort = 3005 } = {}) {
+  const port = resolveServerPortFromEnv({ env, defaultPort });
+  return { port, internalServerUrl: `http://127.0.0.1:${port}` };
+}
+
+export { resolveServerPortFromEnv };
+