portacode 1.5.14.dev2__tar.gz → 1.5.14.dev4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.5.14.dev2
+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.dev2 → 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.dev2'
-__version_tuple__ = version_tuple = (1, 5, 14, 'dev2')
+__version__ = version = '1.5.14.dev4'
+__version_tuple__ = version_tuple = (1, 5, 14, 'dev4')
 
 __commit_id__ = commit_id = None

{portacode-1.5.14.dev2 → 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.dev2 → 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.dev2 → 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.dev2 → portacode-1.5.14.dev4}/portacode/connection/handlers/codex_handlers.py

@@ -86,6 +86,71 @@ def _project_id(message: Dict[str, Any]) -> Optional[str]:
     return message.get("project_id")
 
 
+def _thread_from_result(result: Dict[str, Any]) -> Dict[str, Any]:
+    """Normalize thread/start|resume|read results to a thread object.
+
+    Current app-server returns `{ "thread": { "id": ... } }`. Older fakes /
+    builds may return the thread fields at the top level.
+    """
+    if not isinstance(result, dict):
+        return {}
+    thread = result.get("thread")
+    if isinstance(thread, dict):
+        return thread
+    return result
+
+
+def _thread_id_from_result(result: Dict[str, Any]) -> Optional[str]:
+    thread = _thread_from_result(result)
+    return thread.get("id") or result.get("id") or result.get("threadId")
+
+
+def _threads_from_list_result(result: Dict[str, Any]) -> tuple[list, Optional[str]]:
+    """Normalize thread/list results.
+
+    Current app-server returns `{ "data": [...], "nextCursor": ... }`.
+    """
+    if not isinstance(result, dict):
+        return [], None
+    threads = result.get("data")
+    if threads is None:
+        threads = result.get("threads")
+    if not isinstance(threads, list):
+        threads = []
+    return threads, result.get("nextCursor")
+
+
+def _items_from_read_result(result: Dict[str, Any]) -> list:
+    """Extract conversation items from thread/read (or legacy shapes)."""
+    if not isinstance(result, dict):
+        return []
+    if isinstance(result.get("items"), list):
+        return result["items"]
+    if isinstance(result.get("messages"), list):
+        return result["messages"]
+
+    thread = _thread_from_result(result)
+    turns = thread.get("turns") or result.get("turns") or []
+    items: list = []
+    if isinstance(turns, list):
+        for turn in turns:
+            if not isinstance(turn, dict):
+                continue
+            turn_items = turn.get("items")
+            if isinstance(turn_items, list):
+                items.extend(turn_items)
+    return items
+
+
+def _turn_from_result(result: Dict[str, Any]) -> Dict[str, Any]:
+    if not isinstance(result, dict):
+        return {}
+    turn = result.get("turn")
+    if isinstance(turn, dict):
+        return turn
+    return result
+
+
 class CodexAsyncHandler(AsyncHandler):
     """AsyncHandler that replies to `source_client_session` per WEBSOCKET_PROTOCOL.md."""
 
@@ -173,19 +238,23 @@ class CodexThreadListHandler(CodexAsyncHandler):
         manager = _get_manager(self)
         await manager.ensure_started()
 
-        params: Dict[str, Any] = {"cwd": cwd, "useStateDbOnly": True}
-        limit = message.get("limit")
+        # Default sourceKinds is cli+vscode only; include appServer so IDE chats appear.
+        # Avoid useStateDbOnly:true — it has returned empty lists in some Codex builds.
+        params: Dict[str, Any] = {
+            "cwd": cwd,
+            "sourceKinds": ["cli", "vscode", "appServer"],
+            "limit": message.get("limit") if message.get("limit") is not None else 50,
+        }
         cursor = message.get("cursor")
-        if limit is not None:
-            params["limit"] = limit
         if cursor is not None:
             params["cursor"] = cursor
 
         result = await manager.bridge.call("thread/list", params)
+        threads, next_cursor = _threads_from_list_result(result)
         payload = {
             "event": "codex_thread_list",
-            "threads": result.get("threads", []),
-            "nextCursor": result.get("nextCursor"),
+            "threads": threads,
+            "nextCursor": next_cursor,
         }
         project_id = _project_id(message)
         if project_id:
@@ -217,7 +286,8 @@ class CodexThreadStartHandler(CodexAsyncHandler):
             params["modelProvider"] = message["modelProvider"]
 
         result = await manager.bridge.call("thread/start", params)
-        thread_id = result.get("id") or result.get("threadId")
+        thread = _thread_from_result(result)
+        thread_id = _thread_id_from_result(result)
         if not thread_id:
             raise CodexAppServerError("thread/start did not return a thread id")
 
@@ -226,7 +296,7 @@ class CodexThreadStartHandler(CodexAsyncHandler):
         payload = {
             "event": "codex_thread_started",
             "threadId": thread_id,
-            "thread": result,
+            "thread": thread,
         }
         if project_id:
             payload["project_id"] = project_id
@@ -255,8 +325,11 @@ class CodexThreadResumeHandler(CodexAsyncHandler):
             resume_params["cwd"] = cwd
         await manager.bridge.call("thread/resume", resume_params)
 
-        read_result = await manager.bridge.call("thread/read", {"threadId": thread_id})
-        items = read_result.get("items", read_result.get("messages", []))
+        read_result = await manager.bridge.call(
+            "thread/read",
+            {"threadId": thread_id, "includeTurns": True},
+        )
+        items = _items_from_read_result(read_result)
 
         if cwd and project_id:
             manager.record_thread(thread_id, cwd, project_id)
@@ -305,7 +378,7 @@ class CodexTurnStartHandler(CodexAsyncHandler):
         payload = {
             "event": "codex_turn_started",
             "threadId": thread_id,
-            "turn": result,
+            "turn": _turn_from_result(result),
         }
         if project_id:
             payload["project_id"] = project_id
@@ -371,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.dev2 → 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.dev2 → 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.dev2 → 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.dev2 → 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.dev2 → portacode-1.5.14.dev4}/portacode/tests/test_codex_handlers.py

@@ -43,11 +43,20 @@ class FakeBridge:
     def __init__(self) -> None:
         self.calls: list[tuple[str, dict]] = []
         self.responses: dict[str, Any] = {
-            "thread/start": {"id": "th-1", "name": "New chat"},
-            "thread/list": {"threads": [{"id": "th-1", "name": "Existing chat"}], "nextCursor": None},
-            "thread/resume": {},
-            "thread/read": {"items": [{"id": "msg-1", "role": "user", "text": "hello"}]},
-            "turn/start": {"id": "turn-1", "threadId": "th-1"},
+            # Match current Codex app-server response shapes.
+            "thread/start": {"thread": {"id": "th-1", "name": "New chat"}},
+            "thread/list": {
+                "data": [{"id": "th-1", "name": "Existing chat", "preview": "hi"}],
+                "nextCursor": None,
+            },
+            "thread/resume": {"thread": {"id": "th-1"}},
+            "thread/read": {
+                "thread": {
+                    "id": "th-1",
+                    "turns": [{"id": "turn-1", "items": [{"id": "msg-1", "role": "user", "text": "hello"}]}],
+                }
+            },
+            "turn/start": {"turn": {"id": "turn-1", "threadId": "th-1"}},
             "turn/interrupt": {},
         }
 
@@ -103,6 +112,11 @@ async def test_codex_thread_list():
     assert payload["event"] == "codex_thread_list"
     assert payload["threads"][0]["id"] == "th-1"
     assert payload["project_id"] == "p-1"
+    list_call = manager.bridge.calls[-1]
+    assert list_call[0] == "thread/list"
+    assert list_call[1]["cwd"] == "/tmp/proj"
+    assert "appServer" in list_call[1]["sourceKinds"]
+    assert "useStateDbOnly" not in list_call[1]
 
 
 @pytest.mark.asyncio
@@ -138,6 +152,8 @@ async def test_codex_thread_resume():
     assert payload["event"] == "codex_thread_resumed"
     assert payload["items"][0]["text"] == "hello"
     assert manager._thread_project["th-1"] == "p-1"
+    read_call = next(c for c in manager.bridge.calls if c[0] == "thread/read")
+    assert read_call[1]["includeTurns"] is True
 
 
 @pytest.mark.asyncio

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

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