portacode 1.5.14.dev3__tar.gz → 1.5.14.dev4__tar.gz

{portacode-1.5.14.dev3 → portacode-1.5.14.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.5.14.dev3
+Version: 1.5.14.dev4
 Summary: Portacode CLI client and SDK
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian

{portacode-1.5.14.dev3 → portacode-1.5.14.dev4}/portacode/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.14.dev3'
-__version_tuple__ = version_tuple = (1, 5, 14, 'dev3')
+__version__ = version = '1.5.14.dev4'
+__version_tuple__ = version_tuple = (1, 5, 14, 'dev4')
 
 __commit_id__ = commit_id = None

{portacode-1.5.14.dev3 → portacode-1.5.14.dev4}/portacode/cli.py

@@ -56,7 +56,9 @@ def prepare_codex_command() -> None:
     click.echo(
         click.style(
             "For this terminal only, run: export OPENAI_API_KEY=portacode-local\n"
-            "New terminal sessions are already configured.",
+            "New IDE terminals load /etc/portacode/codex.env automatically.\n"
+            "The Portacode systemd service loads that file via EnvironmentFile "
+            "(restart the service once if this device was prepared before that support).",
             fg="yellow",
         )
     )

{portacode-1.5.14.dev3 → portacode-1.5.14.dev4}/portacode/codex_prepare.py

@@ -6,13 +6,14 @@ import json
 import os
 import platform
 import re
+import shlex
 import shutil
 import subprocess
 import sys
 import urllib.error
 import urllib.request
 from pathlib import Path
-from typing import Iterable
+from typing import Dict, Iterable, Mapping, MutableMapping, Optional
 
 from .codex_loopback_proxy import CODEX_LOOPBACK_HOST, CODEX_LOOPBACK_PORT
 
@@ -30,6 +31,8 @@ env_key = "OPENAI_API_KEY"
 '''
 
 LOCAL_SENTINEL = "portacode-local"
+CODEX_ENV_PATH = Path("/etc/portacode/codex.env")
+OPENAI_API_KEY_ENV = "OPENAI_API_KEY"
 
 
 class CodexPreparationError(RuntimeError):
@@ -142,32 +145,121 @@ def _write_config() -> Path:
     return config_path
 
 
+def read_codex_env_file(path: Optional[Path] = None) -> Dict[str, str]:
+    """Parse KEY=VALUE lines from the managed Codex env file."""
+    path = path or CODEX_ENV_PATH
+    values: Dict[str, str] = {}
+    try:
+        for raw_line in path.read_text(encoding="utf-8").splitlines():
+            line = raw_line.strip()
+            if not line or line.startswith("#"):
+                continue
+            key, separator, value = line.partition("=")
+            if separator and key:
+                values[key] = value
+    except OSError:
+        pass
+    return values
+
+
+def apply_codex_env_to_mapping(
+    env: MutableMapping[str, str],
+    path: Optional[Path] = None,
+) -> None:
+    """Ensure OPENAI_API_KEY (and other managed vars) are present for child processes.
+
+    Shell profiles / IDE terminals already source ``/etc/portacode/codex.env``.
+    The long-running Portacode systemd service does not, so callers that spawn
+    Codex (or interactive shells) must merge this file explicitly.
+    """
+    file_values = read_codex_env_file(path)
+    for key, value in file_values.items():
+        if value:
+            env[key] = value
+    # Always guarantee the local proxy sentinel unless a non-empty value exists.
+    if not (env.get(OPENAI_API_KEY_ENV) or "").strip():
+        env[OPENAI_API_KEY_ENV] = file_values.get(OPENAI_API_KEY_ENV) or LOCAL_SENTINEL
+
+
+def build_codex_subprocess_env(
+    base: Optional[Mapping[str, str]] = None,
+    path: Optional[Path] = None,
+) -> Dict[str, str]:
+    """Environment for Codex CLI / app-server subprocesses."""
+    env = dict(base or os.environ)
+    apply_codex_env_to_mapping(env, path=path)
+    return env
+
+
+def _install_systemd_codex_environment_file() -> None:
+    """Make Portacode's systemd unit load ``/etc/portacode/codex.env`` on start.
+
+    systemd does not source ``/etc/profile.d`` or ``/etc/environment`` for
+    ``Type=simple`` services the way login shells do. A drop-in EnvironmentFile
+    is the reliable propagation path for the agent process itself.
+    """
+    dropin_body = (
+        "# Managed by portacode prepare codex.\n"
+        "[Service]\n"
+        f"EnvironmentFile=-{CODEX_ENV_PATH}\n"
+    )
+    system_unit = Path("/etc/systemd/system/portacode.service")
+    user_unit = Path.home() / ".config/systemd/user/portacode.service"
+
+    if system_unit.exists():
+        dropin_dir = Path("/etc/systemd/system/portacode.service.d")
+        dropin_path = dropin_dir / "codex.conf"
+        script = (
+            f"install -d -m 755 {shlex.quote(str(dropin_dir))} && "
+            f"printf '%s' {shlex.quote(dropin_body)} > {shlex.quote(str(dropin_path))} && "
+            f"chmod 644 {shlex.quote(str(dropin_path))}"
+        )
+        _run([*_sudo_prefix(), "sh", "-c", script])
+        subprocess.run([*_sudo_prefix(), "systemctl", "daemon-reload"], check=False)
+        return
+
+    if user_unit.exists():
+        dropin_dir = Path.home() / ".config/systemd/user/portacode.service.d"
+        dropin_dir.mkdir(parents=True, exist_ok=True)
+        dropin_path = dropin_dir / "codex.conf"
+        dropin_path.write_text(dropin_body, encoding="utf-8")
+        dropin_path.chmod(0o644)
+        subprocess.run(["systemctl", "--user", "daemon-reload"], check=False)
+
+
 def _set_local_sentinel() -> None:
     system = platform.system().lower()
-    os.environ["OPENAI_API_KEY"] = LOCAL_SENTINEL
+    os.environ[OPENAI_API_KEY_ENV] = LOCAL_SENTINEL
     if system == "linux":
         # Portacode terminals load this directly, including sessions started by
         # a long-running agent that pre-dates the prepare command.
         managed_setup = (
             "install -d -m 755 /etc/portacode && "
-            "printf '%s\\n' 'OPENAI_API_KEY=portacode-local' > /etc/portacode/codex.env && "
-            "chmod 644 /etc/portacode/codex.env && "
+            f"printf '%s\\n' '{OPENAI_API_KEY_ENV}={LOCAL_SENTINEL}' > {CODEX_ENV_PATH} && "
+            f"chmod 644 {CODEX_ENV_PATH} && "
             "printf '%s\\n' '# Managed by portacode prepare codex.' "
-            "'if [ -r /etc/portacode/codex.env ]; then' '  set -a' "
-            "'  . /etc/portacode/codex.env' '  set +a' 'fi' > /etc/profile.d/portacode_codex.sh && "
+            f"'if [ -r {CODEX_ENV_PATH} ]; then' '  set -a' "
+            f"'  . {CODEX_ENV_PATH}' '  set +a' 'fi' > /etc/profile.d/portacode_codex.sh && "
             "chmod 644 /etc/profile.d/portacode_codex.sh"
         )
         _run([*_sudo_prefix(), "sh", "-c", managed_setup])
-        _run([*_sudo_prefix(), "sh", "-c", 'grep -q "^OPENAI_API_KEY=portacode-local$" /etc/environment || printf "%s\\n" "OPENAI_API_KEY=portacode-local" >> /etc/environment'])
+        _run([
+            *_sudo_prefix(),
+            "sh",
+            "-c",
+            f'grep -q "^{OPENAI_API_KEY_ENV}={LOCAL_SENTINEL}$" /etc/environment || '
+            f'printf "%s\\n" "{OPENAI_API_KEY_ENV}={LOCAL_SENTINEL}" >> /etc/environment',
+        ])
+        _install_systemd_codex_environment_file()
     elif system == "darwin":
         zshenv = Path.home() / ".zshenv"
-        line = "export OPENAI_API_KEY=portacode-local\n"
+        line = f"export {OPENAI_API_KEY_ENV}={LOCAL_SENTINEL}\n"
         if not zshenv.exists() or line not in zshenv.read_text(encoding="utf-8", errors="ignore"):
             with zshenv.open("a", encoding="utf-8") as handle:
                 handle.write(line)
-        subprocess.run(["launchctl", "setenv", "OPENAI_API_KEY", LOCAL_SENTINEL], check=False)
+        subprocess.run(["launchctl", "setenv", OPENAI_API_KEY_ENV, LOCAL_SENTINEL], check=False)
     elif system == "windows":
-        _run(["setx", "OPENAI_API_KEY", LOCAL_SENTINEL])
+        _run(["setx", OPENAI_API_KEY_ENV, LOCAL_SENTINEL])
 
 
 def _verify_loopback_proxy() -> None:

{portacode-1.5.14.dev3 → portacode-1.5.14.dev4}/portacode/connection/codex_app_server.py

@@ -79,6 +79,10 @@ class CodexAppServer:
                 f"{self.command[0]} not found on PATH. Run `portacode prepare codex` on this device."
             )
 
+        # systemd services do not load shell profile env; merge /etc/portacode/codex.env.
+        from portacode.codex_prepare import build_codex_subprocess_env
+
+        child_env = build_codex_subprocess_env()
         LOGGER.info("Spawning Codex app-server: %s", " ".join(self.command))
         try:
             self._proc = await self._process_factory(
@@ -86,7 +90,7 @@ class CodexAppServer:
                 stdin=asyncio.subprocess.PIPE,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
-                env=None,  # Inherit the environment where `prepare codex` set OPENAI_API_KEY
+                env=child_env,
             )
         except Exception as exc:
             raise CodexAppServerError(f"Failed to spawn codex app-server: {exc}") from exc
@@ -96,6 +100,13 @@ class CodexAppServer:
 
         await self._initialize()
 
+    async def recycle(self) -> None:
+        """Stop a running app-server so the next ``start()`` respawns with fresh env."""
+        async with self._lock:
+            await self._kill_locked()
+            self._closed = False
+            self._initialized.clear()
+
     async def _kill_locked(self) -> None:
         """Tear down the subprocess and reader tasks."""
         for future in list(self._pending.values()):

{portacode-1.5.14.dev3 → portacode-1.5.14.dev4}/portacode/connection/handlers/codex_handlers.py

@@ -444,6 +444,12 @@ class CodexPrepareHandler(CodexAsyncHandler):
         try:
             loop = asyncio.get_running_loop()
             await loop.run_in_executor(None, prepare_codex)
+            # Drop any app-server started before the sentinel was available so
+            # the next chat command respawns with OPENAI_API_KEY injected.
+            try:
+                await manager.bridge.recycle()
+            except Exception:
+                LOGGER.exception("Failed to recycle Codex app-server after prepare")
             payload = {"event": "codex_prepare_done", "success": True}
         except CodexPreparationError as exc:
             LOGGER.warning("codex_prepare failed: %s", exc)

{portacode-1.5.14.dev3 → portacode-1.5.14.dev4}/portacode/connection/handlers/session.py

@@ -15,6 +15,7 @@ from typing import Any, Awaitable, Callable, Dict, Optional, List, TYPE_CHECKING
 
 from platformdirs import user_data_dir
 
+from portacode.codex_prepare import CODEX_ENV_PATH, apply_codex_env_to_mapping
 from portacode.link_capture import prepare_link_capture_bin
 from .runtime_user import get_default_runtime_user, wrap_argv_for_user
 
@@ -38,7 +39,6 @@ _LINK_EVENT_ROOT = Path(user_data_dir("portacode", "portacode")) / "link_events"
 _LINK_EVENT_POLL_INTERVAL = 0.5  # seconds
 LINK_EVENT_THROTTLE_SECONDS = 5.0
 LINK_CAPTURE_ORIGINAL_BROWSER_ENV = "PORTACODE_LINK_CAPTURE_ORIGINAL_BROWSER"
-CODEX_ENV_PATH = Path("/etc/portacode/codex.env")
 
 logger = logging.getLogger(__name__)
 
@@ -72,14 +72,8 @@ _DEFAULT_ENV = {
 def _build_child_env() -> Dict[str, str]:
     """Return a copy of os.environ with sensible fallbacks and managed vars."""
     env = os.environ.copy()
-    try:
-        for raw_line in CODEX_ENV_PATH.read_text(encoding="utf-8").splitlines():
-            key, separator, value = raw_line.partition("=")
-            if separator and key == "OPENAI_API_KEY" and value:
-                # The file is managed locally by ``portacode prepare codex``.
-                env[key] = value
-    except OSError:
-        pass
+    # Managed by ``portacode prepare codex`` (/etc/portacode/codex.env).
+    apply_codex_env_to_mapping(env)
     for k, v in _DEFAULT_ENV.items():
         env.setdefault(k, v)
     env.setdefault("COLUMNS", str(TERMINAL_COLUMNS))

{portacode-1.5.14.dev3 → portacode-1.5.14.dev4}/portacode/service.py

@@ -173,7 +173,12 @@ class _SystemdUserService:
         
         # Capture current SHELL for the service to prevent using /bin/sh in containers/virtualized environments
         current_shell = os.getenv("SHELL", "/bin/bash")
-        env_lines = [f"Environment=SHELL={current_shell}"]
+        env_lines = [
+            f"Environment=SHELL={current_shell}",
+            # Optional until `portacode prepare codex` creates the file. Ensures the
+            # long-running agent (and Codex app-server children) see OPENAI_API_KEY.
+            "EnvironmentFile=-/etc/portacode/codex.env",
+        ]
         if self.system_mode:
             env_lines.append(f"Environment=PORTACODE_DEFAULT_RUNTIME_USER={self.runtime_user}")
             if self.xdg_data_home:

{portacode-1.5.14.dev3 → portacode-1.5.14.dev4}/portacode/test_service.py

@@ -49,6 +49,7 @@ class ServiceCommandTests(TestCase):
 
             unit_text = service.service_path.read_text(encoding="utf-8")
             self.assertIn("ExecStart=/opt/portacode-venv/bin/python -m portacode connect --non-interactive", unit_text)
+            self.assertIn("EnvironmentFile=-/etc/portacode/codex.env", unit_text)
             self.assertIn("--project-path '$$HOME/.openclaw'", unit_text)
             self.assertIn("--project-path '$$HOME/.openclaw/workspace'", unit_text)
             self.assertLess(unit_text.index("$$HOME/.openclaw"), unit_text.index("$$HOME/.openclaw/workspace"))

{portacode-1.5.14.dev3 → portacode-1.5.14.dev4}/portacode/tests/test_codex_app_server.py

@@ -93,9 +93,11 @@ def _factory_for(*processes: FakeProcess):
 
     async def _factory(*_args, **_kwargs):
         try:
-            return next(proc_iter)
+            proc = next(proc_iter)
         except StopIteration as exc:
             raise RuntimeError("No more fake processes") from exc
+        proc.spawn_kwargs = _kwargs
+        return proc
 
     return _factory
 
@@ -111,6 +113,40 @@ async def test_initialize_handshake():
     await bridge.stop()
 
 
+@pytest.mark.asyncio
+async def test_spawn_injects_openai_api_key(tmp_path, monkeypatch):
+    env_file = tmp_path / "codex.env"
+    env_file.write_text("OPENAI_API_KEY=portacode-local\n", encoding="utf-8")
+    monkeypatch.setattr("portacode.codex_prepare.CODEX_ENV_PATH", env_file)
+    monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+
+    proc = FakeProcess([{"jsonrpc": "2.0", "id": 1, "result": {"protocolVersion": "v2"}}])
+    bridge = CodexAppServer(_process_factory=_factory_for(proc))
+    await bridge.start()
+
+    env = getattr(proc, "spawn_kwargs", {}).get("env") or {}
+    assert env.get("OPENAI_API_KEY") == "portacode-local"
+    await bridge.stop()
+
+
+def test_build_codex_subprocess_env_reads_managed_file(tmp_path):
+    from portacode.codex_prepare import build_codex_subprocess_env
+
+    env_file = tmp_path / "codex.env"
+    env_file.write_text("OPENAI_API_KEY=portacode-local\n", encoding="utf-8")
+    env = build_codex_subprocess_env(base={"PATH": "/usr/bin"}, path=env_file)
+    assert env["OPENAI_API_KEY"] == "portacode-local"
+    assert env["PATH"] == "/usr/bin"
+
+
+def test_build_codex_subprocess_env_defaults_sentinel_without_file(tmp_path):
+    from portacode.codex_prepare import LOCAL_SENTINEL, build_codex_subprocess_env
+
+    missing = tmp_path / "missing.env"
+    env = build_codex_subprocess_env(base={}, path=missing)
+    assert env["OPENAI_API_KEY"] == LOCAL_SENTINEL
+
+
 @pytest.mark.asyncio
 async def test_request_response_correlation():
     # Only preload the initialize response. Queuing the call response early can

{portacode-1.5.14.dev3 → portacode-1.5.14.dev4}/portacode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.5.14.dev3
+Version: 1.5.14.dev4
 Summary: Portacode CLI client and SDK
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian