happy-stacks 0.6.11 → 0.6.13

package/scripts/monorepo_port.test.mjs

@@ -275,6 +275,76 @@ test('monorepo port can clone the target monorepo into a new directory', async (
   assert.equal(content, 'v2\n');
 });
 
+test('monorepo port guide auto-clones target when --target does not exist', async (t) => {
+  const root = await withTempRoot(t);
+  const seedMono = join(root, 'seed-mono');
+  const target = join(root, 'target-guide-autoclone'); // does not exist yet
+  const sourceCli = join(root, 'source-cli');
+  const env = gitEnv();
+
+  // Seed monorepo repo that will be cloned into `target`
+  await initMonorepoStub({ dir: seedMono, env, seed: { 'cli/hello.txt': 'v1\n' } });
+
+  // Source CLI repo with one change commit (v1 -> v2)
+  const base = await initSplitRepoStub({ dir: sourceCli, env, name: 'cli', seed: { 'hello.txt': 'v1\n' } });
+  await writeFile(join(sourceCli, 'hello.txt'), 'v2\n', 'utf-8');
+  await run('git', ['add', '.'], { cwd: sourceCli, env });
+  await run('git', ['commit', '-q', '-m', 'feat: update hello'], { cwd: sourceCli, env });
+
+  // Guide requires a TTY, but with all args provided it should not prompt.
+  // We spawn so the guide sees a TTY (required), but still feed no input.
+  const child = spawn(
+    process.execPath,
+    [
+      join(process.cwd(), 'scripts', 'monorepo.mjs'),
+      'port',
+      'guide',
+      `--target=${target}`,
+      `--target-repo=${seedMono}`,
+      '--branch=port/test-guide-autoclone',
+      '--3way',
+      `--from-happy-cli=${sourceCli}`,
+      `--from-happy-cli-base=${base}`,
+      '--json',
+    ],
+    {
+      cwd: process.cwd(),
+      env: { ...env, HAPPY_STACKS_TEST_TTY: '1', HAPPY_STACKS_DISABLE_LLM_AUTOEXEC: '1' },
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }
+  );
+  t.after(() => {
+    try {
+      child.kill('SIGKILL');
+    } catch {
+      // ignore
+    }
+  });
+  let out = '';
+  let err = '';
+  let exitCode = null;
+  child.stdout?.on('data', (d) => (out += d.toString()));
+  child.stderr?.on('data', (d) => (err += d.toString()));
+  child.on('exit', (code) => {
+    exitCode = code;
+  });
+
+  const waitForExit = async (timeoutMs) => {
+    const started = Date.now();
+    while (Date.now() - started < timeoutMs) {
+      if (exitCode != null) return;
+      // eslint-disable-next-line no-await-in-loop
+      await new Promise((r) => setTimeout(r, 20));
+    }
+    throw new Error(`timeout waiting for guide to exit\nstdout:\n${out}\nstderr:\n${err}`);
+  };
+  await waitForExit(20_000);
+  assert.equal(exitCode, 0, `expected guide to exit 0\nstdout:\n${out}\nstderr:\n${err}`);
+
+  const content = (await readFile(join(target, 'cli', 'hello.txt'), 'utf-8')).toString();
+  assert.equal(content, 'v2\n');
+});
+
 test('monorepo port accepts source repo URLs by cloning them into a temp checkout', async (t) => {
   const root = await withTempRoot(t);
   const target = join(root, 'target-mono');
@@ -721,6 +791,72 @@ test('monorepo port continue runs git am --continue after conflicts are resolved
   assert.equal(content, 'value=source\n');
 });
 
+test('monorepo port continue --stage stages conflicted files before continuing', async (t) => {
+  const root = await withTempRoot(t);
+  const target = join(root, 'target-mono');
+  const sourceCli = join(root, 'source-cli');
+
+  // Target monorepo stub with cli/hello.txt="value=target".
+  await mkdir(target, { recursive: true });
+  await run('git', ['init', '-q'], { cwd: target, env: gitEnv() });
+  await run('git', ['checkout', '-q', '-b', 'main'], { cwd: target, env: gitEnv() });
+  await mkdir(join(target, 'expo-app'), { recursive: true });
+  await mkdir(join(target, 'cli'), { recursive: true });
+  await mkdir(join(target, 'server'), { recursive: true });
+  await writeFile(join(target, 'expo-app', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(target, 'cli', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(target, 'server', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(target, 'cli', 'hello.txt'), 'value=target\n', 'utf-8');
+  await run('git', ['add', '.'], { cwd: target, env: gitEnv() });
+  await run('git', ['commit', '-q', '-m', 'chore: init monorepo'], { cwd: target, env: gitEnv() });
+
+  // Source CLI repo with base="value=base" and a commit changing to "value=source".
+  await mkdir(sourceCli, { recursive: true });
+  await run('git', ['init', '-q'], { cwd: sourceCli, env: gitEnv() });
+  await run('git', ['checkout', '-q', '-b', 'main'], { cwd: sourceCli, env: gitEnv() });
+  await writeFile(join(sourceCli, 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(sourceCli, 'hello.txt'), 'value=base\n', 'utf-8');
+  await run('git', ['add', '.'], { cwd: sourceCli, env: gitEnv() });
+  await run('git', ['commit', '-q', '-m', 'chore: init cli'], { cwd: sourceCli, env: gitEnv() });
+  const base = (await runCapture('git', ['rev-parse', 'HEAD'], { cwd: sourceCli, env: gitEnv() })).trim();
+  await writeFile(join(sourceCli, 'hello.txt'), 'value=source\n', 'utf-8');
+  await run('git', ['add', '.'], { cwd: sourceCli, env: gitEnv() });
+  await run('git', ['commit', '-q', '-m', 'feat: update hello'], { cwd: sourceCli, env: gitEnv() });
+
+  // Start a port that will stop with an am conflict.
+  await assert.rejects(
+    async () =>
+      await runCapture(
+        process.execPath,
+        [
+          join(process.cwd(), 'scripts', 'monorepo.mjs'),
+          'port',
+          `--target=${target}`,
+          `--branch=port/test-continue-stage`,
+          `--from-happy-cli=${sourceCli}`,
+          `--from-happy-cli-base=${base}`,
+          '--3way',
+        ],
+        { cwd: process.cwd(), env: gitEnv() }
+      )
+  );
+
+  // Resolve the conflict by choosing "value=source", but DO NOT stage it.
+  await writeFile(join(target, 'cli', 'hello.txt'), 'value=source\n', 'utf-8');
+
+  const out = await runCapture(
+    process.execPath,
+    [join(process.cwd(), 'scripts', 'monorepo.mjs'), 'port', 'continue', `--target=${target}`, '--stage', '--json'],
+    { cwd: process.cwd(), env: gitEnv() }
+  );
+  const parsed = JSON.parse(out.trim());
+  assert.equal(parsed.ok, true);
+  assert.equal(parsed.inProgress, false);
+
+  const content = (await readFile(join(target, 'cli', 'hello.txt'), 'utf-8')).toString();
+  assert.equal(content, 'value=source\n');
+});
+
 test('monorepo port guide refuses to run in non-tty mode', async (t) => {
   const root = await withTempRoot(t);
   const target = join(root, 'target-mono');

package/scripts/provision/linux-ubuntu-review-pr.sh

@@ -73,7 +73,11 @@ corepack prepare pnpm@latest --activate >/dev/null 2>&1 || true
 
 echo "[provision] configuring happy-stacks VM defaults (ports)..."
 # When port-forwarding a VM to the macOS host, it's convenient to avoid using the host's default ports (3005/8081).
-# Persist these as happy-stacks home defaults so `npx happy-stacks ...` picks them up automatically.
+# Persist these as happy-stacks *home* defaults so non-sandbox `happys ...` commands pick them up automatically.
+#
+# NOTE: `npx happy-stacks review-pr ...` runs in a fully isolated sandbox (separate HOME), so it will NOT read
+# this file by default. For review-pr in a VM, pass `--vm-ports` (or explicit `--stack-port-start=...`) to
+# force the port ranges inside the sandbox.
 HS_HOME="${HOME}/.happy-stacks"
 mkdir -p "$HS_HOME"
 ENV_LOCAL="${HS_HOME}/env.local"

package/scripts/provision/macos-lima-happy-vm.sh

@@ -48,15 +48,23 @@ fi
 
 VM_NAME="${1:-happy-test}"
 TEMPLATE="${LIMA_TEMPLATE:-ubuntu-24.04}"
+LIMA_MEMORY="${LIMA_MEMORY:-8GiB}"
+TEMPLATE_LOCATOR="${TEMPLATE}"
+if [[ "${TEMPLATE_LOCATOR}" == template://* ]]; then
+  TEMPLATE_LOCATOR="template:${TEMPLATE_LOCATOR#template://}"
+elif [[ "${TEMPLATE_LOCATOR}" != template:* ]]; then
+  TEMPLATE_LOCATOR="template:${TEMPLATE_LOCATOR}"
+fi
 LIMA_DIR="${HOME}/.lima/${VM_NAME}"
 LIMA_YAML="${LIMA_DIR}/lima.yaml"
 
 echo "[lima] vm: ${VM_NAME}"
 echo "[lima] template: ${TEMPLATE}"
+echo "[lima] memory: ${LIMA_MEMORY} (override with LIMA_MEMORY=...)"
 
 if [[ ! -f "${LIMA_YAML}" ]]; then
   echo "[lima] creating VM..."
-  limactl create --name "${VM_NAME}" --tty=false "template://${TEMPLATE}"
+  limactl create --name "${VM_NAME}" --tty=false "${TEMPLATE_LOCATOR}"
 fi
 
 if [[ ! -f "${LIMA_YAML}" ]]; then
@@ -70,14 +78,17 @@ limactl stop "${VM_NAME}" >/dev/null 2>&1 || true
 echo "[lima] configuring port forwarding (localhost)..."
 cp -a "${LIMA_YAML}" "${LIMA_YAML}.bak.$(date +%Y%m%d-%H%M%S)"
 
-python3 - <<'PY'
+VM_NAME="${VM_NAME}" LIMA_YAML="${LIMA_YAML}" LIMA_MEMORY="${LIMA_MEMORY}" python3 - <<'PY'
 import os, re
 from pathlib import Path
 
 vm_name = os.environ["VM_NAME"]
 path = Path(os.environ["LIMA_YAML"])
+memory = os.environ.get("LIMA_MEMORY", "8GiB")
 text = path.read_text(encoding="utf-8")
 
+MEM_MARK_BEGIN = "# --- happy-stacks vm sizing (added by happy-local) ---"
+MEM_MARK_END = "# --- /happy-stacks vm sizing ---"
 MARK_BEGIN = "# --- happy-stacks port forwards (added by happy-local) ---"
 MARK_END = "# --- /happy-stacks port forwards ---"
 
@@ -86,6 +97,12 @@ entries = [
     "  - guestPortRange: [18000, 19099]\n    hostPortRange:  [18000, 19099]\n",
 ]
 
+mem_block = (
+    f"\n{MEM_MARK_BEGIN}\n"
+    f'memory: "{memory}"\n'
+    f"{MEM_MARK_END}\n"
+)
+
 block_as_section = (
     f"\n{MARK_BEGIN}\n"
     "portForwards:\n"
@@ -99,6 +116,20 @@ block_as_list_items = (
     f"  # --- /happy-stacks port forwards ---\n"
 )
 
+if MEM_MARK_BEGIN in text and MEM_MARK_END in text:
+  text = re.sub(
+      re.escape(MEM_MARK_BEGIN) + r"[\\s\\S]*?" + re.escape(MEM_MARK_END) + r"\\n?",
+      mem_block.strip("\n") + "\n",
+      text,
+      flags=re.MULTILINE,
+  )
+else:
+  m = re.search(r"^memory:\\s*.*$", text, flags=re.MULTILINE)
+  if m:
+    text = re.sub(r"^memory:\\s*.*$", f'memory: "{memory}"', text, flags=re.MULTILINE)
+  else:
+    text = text.rstrip() + mem_block
+
 if MARK_BEGIN in text and MARK_END in text:
   text = re.sub(
       re.escape(MARK_BEGIN) + r"[\\s\\S]*?" + re.escape(MARK_END) + r"\\n?",
@@ -138,5 +169,6 @@ Then:
 
 Tip:
   Open the printed URLs on your macOS host via http://localhost:<port> or http://*.localhost:<port>.
+  For `npx happy-stacks review-pr ...` inside the VM, pass `--vm-ports` so stack ports land in the forwarded ranges.
 EOF