support: drop .sh wrappers, rename Python files to CLI names, fix streaming output

- Rename install_browser.py → install-browser.py
- Rename install_openspec.py → install-openspec.py
- Rename browser_state_cleanup.py → browser-state-cleanup.py
- Rename lpb_config.py → lpb-config.py
- Delete wrapper scripts: install-browser.sh, validate.sh,
  install-openspec.sh, browser-state-cleanup.sh, build.sh, lpb-config
- Update Dockerfile COPY lines and symlinks to point to .py files
  directly (no .sh extension on symlinks or targets)
- Update test imports to use importlib.import_module() for hyphenated names
- Clean up docstring references to old .sh names
- Fix install_agent_browser() to stream subprocess output instead of
  capturing it — agent-browser install --with-deps progress is now visible
- Fix install_openspec() to stream npm install -g output — npm progress
  is now visible during installation
- lpb-config moved to /opt/pi-support/ for sys.path resolution + symlink
  from ~/.local/bin/

Author: localpibox

Dockerfile

@@ -163,8 +163,7 @@ FROM base AS cli
 
 # ── Support utilities (moved from config/support/ to devstack/support/) ──
 # Copied to /opt/pi-support/ — used by start.sh at runtime
-COPY --chmod=755 support/browser-state-cleanup.sh /opt/pi-support/browser-state-cleanup.sh
-COPY --chmod=755 support/browser_state_cleanup.py /opt/pi-support/browser_state_cleanup.py
+COPY --chmod=755 support/browser-state-cleanup.py /opt/pi-support/browser-state-cleanup.py
 COPY support/browser-validate.ts /opt/pi-support/browser-validate.ts
 COPY --chmod=755 support/_lib.sh /opt/pi-support/_lib.sh
 COPY support/session-uuid.ts /opt/pi-support/session-uuid.ts
@@ -178,12 +177,9 @@ COPY support/schemas/ /opt/pi-support/schemas/
 COPY scripts/localpibox/ /opt/pi-support/localpibox/
 
 # ── Devstack deployment scripts ──
-COPY --chmod=755 support/install-browser.sh /opt/devstack/install-browser.sh
-COPY --chmod=755 support/install_browser.py /opt/devstack/install_browser.py
-COPY --chmod=755 support/validate.sh /opt/devstack/validate.sh
+COPY --chmod=755 support/install-browser.py /opt/devstack/install-browser.py
 COPY --chmod=755 support/validate.py /opt/devstack/validate.py
-COPY --chmod=755 support/install-openspec.sh /opt/pi-support/install-openspec.sh
-COPY --chmod=755 support/install_openspec.py /opt/pi-support/install_openspec.py
+COPY --chmod=755 support/install-openspec.py /opt/pi-support/install-openspec.py
 COPY --chmod=755 support/start.sh /opt/devstack/start.sh
 COPY lpb.conf.env /opt/devstack/lpb.conf.env
 COPY lpb.stack.env /opt/devstack/lpb.stack.env
@@ -195,14 +191,16 @@ COPY --chmod=755 support/entrypoint-cli.sh /opt/devstack/entrypoint-cli.sh
 # lpb) rather than at container first-run — ~/.local/bin is not a mount, so
 # a first-run-only ln would vanish on the next rebuild.
 RUN mkdir -p /home/lpb/.local/bin \
-    && ln -sf /opt/devstack/install-browser.sh /home/lpb/.local/bin/install-browser.sh \
-    && ln -sf /opt/devstack/validate.sh /home/lpb/.local/bin/validate.sh \
-    && ln -sf /opt/pi-support/install-openspec.sh /home/lpb/.local/bin/install-openspec.sh \
-    && ln -sf /opt/pi-support/browser-state-cleanup.sh /home/lpb/.local/bin/browser-state-cleanup.sh
+    && ln -sf /opt/devstack/install-browser.py /home/lpb/.local/bin/install-browser \
+    && ln -sf /opt/devstack/validate.py /home/lpb/.local/bin/validate \
+    && ln -sf /opt/pi-support/install-openspec.py /home/lpb/.local/bin/install-openspec \
+    && ln -sf /opt/pi-support/browser-state-cleanup.py /home/lpb/.local/bin/browser-state-cleanup \
+    && ln -sf /opt/pi-support/lpb-config.py /home/lpb/.local/bin/lpb-config
 
 # ── Shell PATH helper ───────────────────────────────────────────────────────
-COPY --chmod=755 support/lpb-config /home/lpb/.local/bin/lpb-config
-COPY --chmod=755 support/lpb_config.py /home/lpb/.local/bin/lpb_config.py
+# lpb-config.py needs to live under /opt/pi-support/ for its sys.path resolution.
+# A symlink at ~/.local/bin/lpb-config gives users the clean CLI name.
+COPY --chmod=755 support/lpb-config.py /opt/pi-support/lpb-config.py
 
 # ── Root operations: ownership + gitconfig + shell PATH ─────────────────────
 USER root

scripts/test_localpibox.py

@@ -7,14 +7,15 @@
   - localpibox.run    — subprocess helpers, tool discovery, container detection
   - localpibox.cli    — prompts, common flags, fatal-error helper
   - support/build.py  — env loading, build-arg mapping, docker command
-  - browser_state_cleanup — session pruning (age + count)
-  - backup_repos.py   — gh repo listing + mirror cloning
+  - browser-state-cleanup — session pruning (age + count)
+  - backup-repos.py     — gh repo listing + mirror cloning
 
 Runs with plain Python (no third-party deps), mirroring scripts/test_lpb.py.
 """
 
 from __future__ import annotations
 
+import importlib  # noqa: E402
 import datetime
 import io
 import os
@@ -39,12 +40,12 @@
 from localpibox import run as run_mod  # noqa: E402
 from localpibox import cli as cli_mod  # noqa: E402
 import build  # noqa: E402
-import browser_state_cleanup as bsc  # noqa: E402
-import backup_repos  # noqa: E402
-import lpb_config  # noqa: E402
-import validate  # noqa: E402
-import install_browser  # noqa: E402
-import install_openspec  # noqa: E402
+bsc = importlib.import_module('browser-state-cleanup')
+backup_repos = importlib.import_module('backup_repos')
+lc = importlib.import_module('lpb-config')
+validate = importlib.import_module('validate')
+ib = importlib.import_module('install-browser')
+iospec = importlib.import_module('install-openspec')
 
 
 # ═══════════════════════════════════════════════════════════════════════════
@@ -495,7 +496,7 @@ def test_lpb_config_migrate_legacy_layout(tmpdir):
     (pi_root / ".initialized").touch()
     (pi_root / "agent").mkdir()
     cons = _quiet_console()
-    lpb_config.migrate_legacy_layout(pi_root, tmpdir / "agent_dir", cons)
+    lc.migrate_legacy_layout(pi_root, tmpdir / "agent_dir", cons)
     assert (tmpdir / "agent_dir" / "auth.json").exists()
     assert (pi_root / ".initialized").exists()       # marker preserved
     assert (pi_root / "agent").exists()              # subdir preserved
@@ -509,86 +510,86 @@ def test_lpb_config_migrate_noop_when_already_migrated(tmpdir):
     agent.mkdir()
     (agent / ".git").mkdir()
     cons = _quiet_console()
-    lpb_config.migrate_legacy_layout(pi_root, agent, cons)  # must not raise
+    lc.migrate_legacy_layout(pi_root, agent, cons)  # must not raise
     assert True
 
 
 def test_lpb_config_update_clones(tmpdir):
     remote = _setup_git_remote(tmpdir)
     agent = tmpdir / "agent"
     cons = _quiet_console()
-    code = lpb_config.cmd_update(agent, str(remote), "main", cons)
+    code = lc.cmd_update(agent, str(remote), "main", cons)
     assert code == 0
     assert (agent / "f").exists()
 
 
 def test_lpb_config_update_fast_forward(tmpdir):
     remote = _setup_git_remote(tmpdir)
     agent = tmpdir / "agent"
-    lpb_config.cmd_update(agent, str(remote), "main", _quiet_console())
+    lc.cmd_update(agent, str(remote), "main", _quiet_console())
     _push_commit(tmpdir / "work", "two", "two")
     cons = _quiet_console()
-    assert lpb_config.cmd_update(agent, str(remote), "main", cons) == 0
+    assert lc.cmd_update(agent, str(remote), "main", cons) == 0
     assert (agent / "f").read_text() == "two"
 
 
 def test_lpb_config_update_refuses_when_dirty(tmpdir):
     remote = _setup_git_remote(tmpdir)
     agent = tmpdir / "agent"
-    lpb_config.cmd_update(agent, str(remote), "main", _quiet_console())
+    lc.cmd_update(agent, str(remote), "main", _quiet_console())
     _push_commit(tmpdir / "work", "two", "two")
     (agent / "local").write_text("keep")  # untracked = dirty
     cons = _quiet_console()
-    assert lpb_config.cmd_update(agent, str(remote), "main", cons) == 1
+    assert lc.cmd_update(agent, str(remote), "main", cons) == 1
     assert (agent / "local").exists()
 
 
 def test_lpb_config_reset_force(tmpdir):
     remote = _setup_git_remote(tmpdir)
     agent = tmpdir / "agent"
-    lpb_config.cmd_update(agent, str(remote), "main", _quiet_console())
+    lc.cmd_update(agent, str(remote), "main", _quiet_console())
     _push_commit(tmpdir / "work", "two", "two")
     (agent / "junk").write_text("x")
     cons = _quiet_console()
-    assert lpb_config.cmd_reset(agent, str(remote), "main", cons, force=True) == 0
+    assert lc.cmd_reset(agent, str(remote), "main", cons, force=True) == 0
     assert not (agent / "junk").exists()
     assert (agent / "f").read_text() == "two"
 
 
 def test_lpb_config_reset_abort_without_confirmation(tmpdir):
     remote = _setup_git_remote(tmpdir)
     agent = tmpdir / "agent"
-    lpb_config.cmd_update(agent, str(remote), "main", _quiet_console())
+    lc.cmd_update(agent, str(remote), "main", _quiet_console())
     (agent / "junk").write_text("x")
     cons = _quiet_console()
-    assert lpb_config.cmd_reset(agent, str(remote), "main", cons, force=False, inp=io.StringIO("n\n")) == 0
+    assert lc.cmd_reset(agent, str(remote), "main", cons, force=False, inp=io.StringIO("n\n")) == 0
     assert (agent / "junk").exists()
 
 
 def test_lpb_config_status_states(tmpdir):
     remote = _setup_git_remote(tmpdir)
     agent = tmpdir / "agent"
-    lpb_config.cmd_update(agent, str(remote), "main", _quiet_console())
+    lc.cmd_update(agent, str(remote), "main", _quiet_console())
     out, err = io.StringIO(), io.StringIO()
     cons = log_mod.Console(color=False, out=out, err=err)
-    assert lpb_config.cmd_status(agent, str(remote), "main", cons) == 0
+    assert lc.cmd_status(agent, str(remote), "main", cons) == 0
     text = out.getvalue() + err.getvalue()
     assert "Current:" in text and "Remote:" in text and "clean" in text
     # no repo yet
     out2, err2 = io.StringIO(), io.StringIO()
     cons2 = log_mod.Console(color=False, out=out2, err=err2)
-    assert lpb_config.cmd_status(tmpdir / "nope", str(remote), "main", cons2) == 0
+    assert lc.cmd_status(tmpdir / "nope", str(remote), "main", cons2) == 0
     assert "No config repo" in (out2.getvalue() + err2.getvalue())
 
 
 def test_lpb_config_merge_uptodate(tmpdir):
     remote = _setup_git_remote(tmpdir)
     agent = tmpdir / "agent"
-    lpb_config.cmd_update(agent, str(remote), "main", _quiet_console())
+    lc.cmd_update(agent, str(remote), "main", _quiet_console())
     cons = _quiet_console()
-    assert lpb_config.cmd_merge(agent, str(remote), "main", cons) == 0
+    assert lc.cmd_merge(agent, str(remote), "main", cons) == 0
     # merge when no repo -> error
-    assert lpb_config.cmd_merge(tmpdir / "nope", str(remote), "main", _quiet_console()) == 1
+    assert lc.cmd_merge(tmpdir / "nope", str(remote), "main", _quiet_console()) == 1
 
 
 # ═══════════════════════════════════════════════════════════════════════════
@@ -690,8 +691,8 @@ def test_validate_pi_cli_missing(tmpdir):
 
 def test_install_browser_fetch_version():
     payload = b'{"channels":{"Stable":{"version":"130.0.6723.58"}}}'
-    with mock.patch.object(install_browser.urllib.request, "urlopen", return_value=io.BytesIO(payload)):
-        assert install_browser.fetch_stable_chrome_version() == "130.0.6723.58"
+    with mock.patch.object(ib.urllib.request, "urlopen", return_value=io.BytesIO(payload)):
+        assert ib.fetch_stable_chrome_version() == "130.0.6723.58"
 
 
 def test_install_browser_skips_existing_chrome(tmpdir):
@@ -701,7 +702,7 @@ def test_install_browser_skips_existing_chrome(tmpdir):
          mock.patch.object(install_browser, "fetch_stable_chrome_version", return_value=version):
         (tmpdir / f"chrome-{version}" / "chrome-linux64").mkdir(parents=True)
         (tmpdir / f"chrome-{version}" / "chrome-linux64" / "chrome").touch()
-        assert install_browser.install_chrome(cons) == 0
+        assert ib.install_chrome(cons) == 0
         assert "already installed" in cons.err.getvalue()
 
 
@@ -710,14 +711,14 @@ def test_install_browser_verify_no_chrome(tmpdir):
     with mock.patch.object(install_browser, "CHROME_BASE", tmpdir), \
          mock.patch.object(install_browser, "SYSTEM_CHROME", tmpdir / "nope"), \
          mock.patch.object(install_browser, "which", return_value=None):
-        assert install_browser.verify_installation(cons) == 1
+        assert ib.verify_installation(cons) == 1
         assert "Chrome binary not found" in cons.err.getvalue()
 
 
 def test_install_browser_agent_install_missing_binary(tmpdir):
     cons = _quiet_console()
     with mock.patch.object(install_browser, "which", return_value=None):
-        assert install_browser.install_agent_browser(cons) == 1
+        assert ib.install_agent_browser(cons) == 1
         assert "not found" in cons.err.getvalue()
 
 
@@ -731,7 +732,7 @@ def fake_run(args, timeout=600, cwd=None):
 
     with mock.patch.object(install_browser, "which", return_value="/bin/agent-browser"), \
          mock.patch.object(install_browser, "run_cmd", side_effect=fake_run):
-        assert install_browser.install_agent_browser(cons) == 0
+        assert ib.install_agent_browser(cons) == 0
     assert calls == [
         ["agent-browser", "install"],
         ["agent-browser", "install", "--with-deps"],
@@ -746,16 +747,16 @@ def test_openspec_skips_when_installed(tmpdir):
     cons = _quiet_console()
     with mock.patch.object(install_openspec, "which", return_value="/bin/openspec"), \
          mock.patch.object(install_openspec, "run_cmd", return_value=("1.2.3", "", 0)):
-        assert install_openspec.install_openspec(cons) == 0
+        assert iospec.install_openspec(cons) == 0
         assert "already installed" in cons.out.getvalue()
 
 
 def test_openspec_install_retries_then_fails(tmpdir):
     cons = _quiet_console()
     with mock.patch.object(install_openspec, "which", return_value=None), \
          mock.patch.object(install_openspec, "run_cmd", return_value=("", "npm err", 1)), \
-         mock.patch.object(install_openspec.time, "sleep", return_value=None):
-        assert install_openspec.install_openspec(cons) == 1
+         mock.patch.object(iospec.time, "sleep", return_value=None):
+        assert iospec.install_openspec(cons) == 1
         assert "3 attempts" in cons.err.getvalue()
 
 
@@ -764,7 +765,7 @@ def test_openspec_init_new(tmpdir):
     target.mkdir()
     cons = _quiet_console()
     with mock.patch.object(install_openspec, "run_cmd", return_value=("", "", 0)) as m:
-        assert install_openspec.init_openspec(target, cons) == 0
+        assert iospec.init_openspec(target, cons) == 0
     assert m.call_args.args[0] == ["openspec", "init", "--tools", "pi"]
 
 
@@ -773,7 +774,7 @@ def test_openspec_init_existing_runs_update(tmpdir):
     (target / "openspec").mkdir(parents=True)
     cons = _quiet_console()
     with mock.patch.object(install_openspec, "run_cmd", return_value=("", "", 0)) as m:
-        assert install_openspec.init_openspec(target, cons) == 0
+        assert iospec.init_openspec(target, cons) == 0
     assert m.call_args.args[0] == ["openspec", "update"]
 
 
@@ -786,20 +787,20 @@ def test_openspec_verify(tmpdir):
     (target / ".pi" / "prompts" / "opsx-apply.md").write_text("x")
     (target / ".pi" / "skills" / "openspec-foo").mkdir(parents=True)
     cons = _quiet_console()
-    assert install_openspec.verify_installation(target, cons) == 0
+    assert iospec.verify_installation(target, cons) == 0
     assert "2 command files" in cons.out.getvalue()
 
 
 def test_openspec_verify_missing_openspec(tmpdir):
     target = tmpdir / "proj"
     target.mkdir()
     cons = _quiet_console()
-    assert install_openspec.verify_installation(target, cons) == 1
+    assert iospec.verify_installation(target, cons) == 1
     assert "missing" in cons.err.getvalue()
 
 
 def test_openspec_resolve_target(tmpdir):
-    assert install_openspec.resolve_target_dir(str(tmpdir)) == tmpdir.resolve()
+    assert iospec.resolve_target_dir(str(tmpdir)) == tmpdir.resolve()
 
 
 # ═══════════════════════════════════════════════════════════════════════════

support/browser_state_cleanup.py support/browser-state-cleanup.pysupport/browser_state_cleanup.py renamed to support/browser-state-cleanup.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """browser-state-cleanup — housekeeping for agent-browser session state.
 
-Python port of support/browser-state-cleanup.sh.
+Python port of support/browser-state-cleanup.
 
 Removes session dirs older than ``--max-age-days`` OR when the count exceeds
 ``--max-count``, keeping the most recent ones. Optionally kills orphaned

support/browser-state-cleanup.sh

@@ -1,15 +1,15 @@
 #!/usr/bin/env python3
 """install-browser — Install Chrome + agent-browser (with system deps).
 
-Python port of support/install-browser.sh.
+Python port of support/install-browser.
 
 Downloads Chrome-for-Testing and runs ``agent-browser install --with-deps``,
 which uses Playwright's dependency resolver to install only the exact
 libraries needed for the downloaded Chrome version.
 
 Usage:
   Inside container (as root or with sudo):
-    bash /opt/devstack/install-browser.sh
+    /opt/devstack/install-browser
 """
 
 from __future__ import annotations
@@ -31,6 +31,7 @@
 from localpibox.cli import add_common_args, console_from_args, install_sigpipe_handler  # noqa: E402
 from localpibox.log import Console  # noqa: E402
 from localpibox.run import is_container, run_cmd, which  # noqa: E402
+import subprocess  # noqa: E402
 
 CHROME_BASE = Path("/home/lpb/.agent-browser/browsers")
 SYSTEM_CHROME = Path("/opt/google/chrome/chrome")
@@ -100,15 +101,27 @@ def install_agent_browser(cons: Console) -> int:
         cons.error("agent-browser binary not found")
         return 1
 
-    out, err, code = run_cmd(["agent-browser", "install"], timeout=600)
-    if code:
-        cons.error(f"agent-browser install failed ({err.strip() or out.strip()})")
+    def _run_agent(*args: str) -> subprocess.CompletedProcess[str]:
+        """Run agent-browser command, streaming stdout/stderr to the user."""
+        r = subprocess.run(
+            ["agent-browser"] + list(args),
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+            timeout=600,
+            check=False,
+        )
+        return r
+
+    result_install = _run_agent("install")
+    if result_install.returncode != 0:
+        cons.error("agent-browser install failed")
         return 1
-    cons.info("agent-browser installed successfully")
 
-    out, err, code = run_cmd(["agent-browser", "install", "--with-deps"], timeout=600)
-    if code:
+    result_deps = _run_agent("install", "--with-deps")
+    if result_deps.returncode != 0:
         cons.warn("Some system dependencies may be missing; Chrome may fail at runtime")
+
+    cons.info("agent-browser installed successfully")
     return 0