python-codex 0.2.2__tar.gz → 0.2.3__tar.gz

{python_codex-0.2.2 → python_codex-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-codex
-Version: 0.2.2
+Version: 0.2.3
 Summary: A minimal Python extraction of Codex's main agent loop
 License-File: LICENSE
 Requires-Python: >=3.6.2
@@ -165,15 +165,16 @@ pycodex --put @127.0.0.1:5577
 pycodex --put /data/.codex/@127.0.0.1:5577
 pycodex --call SECRET-CALLID@127.0.0.1:5577 "Reply with exactly OK."
 pycodex doctor
-pycodex-ws --listen 0.0.0.0:6007 --board ./board.html
+pycodex-ws --listen 0.0.0.0:6007 --workspace-config ./workspaces.json
+pycodex-ws --listen 0.0.0.0:6007 --workspace-config ./workspaces.json --password 12345
 ```
 
 Current behavior:
 
 - with no argv prompt and a TTY stdin, enter interactive mode
 - with an argv prompt or piped stdin, run a single turn
-- `pycodex-ws` starts the standalone browser workspace with a board pane and a
-  pycodex session pane
+- `pycodex-ws` starts the standalone browser workspace manager and serves each
+  workspace with a board pane and a pycodex session pane
 - interactive mode supports `/exit` and `/quit`
 - interactive mode shows a compact event stream for user-visible phases such as
   tool execution and model follow-up after tool results
@@ -204,6 +205,22 @@ Current behavior:
   non-persisted follow-up session and submits the file contents as the next
   user instruction; this is intended for side-effect follow-ups such as
   Feishu notifications
+- `/link <feishu-email|open_id|chat_id>` attaches the current interactive
+  session to a Feishu card; multiple sessions in the same pycodex process share
+  one Feishu long-connection listener and route card actions by message id
+- `pycodex-ws --workspace-config workspaces.json` serves workspace boards from
+  one process. The JSON file can be either a list or
+  `{"workspaces": [...]}`; each entry uses `board` and `work_dir`, with optional
+  display/URL `id`, and is exposed at `/w/<id>/`. Internally the resolved
+  `board` path is the workspace identity, so adding the same board path twice is
+  rejected even with a different name. Relative `board` and `work_dir` paths
+  resolve from the config file directory. The root path `/` shows a workspaces
+  management page with `add_workspace(name=None, dir="./", board=None)` and
+  `delete(name)` controls; omitted names become `workspace-1`, `workspace-2`,
+  etc. If `board` is omitted when adding a workspace, pycodex assigns a random
+  writable `/tmp/pcws-*.html` board path. Add/delete actions and later
+  session-state saves refresh the JSON file. `--password <value>` enables a
+  password-only login page for workspace pages, APIs, and websocket connections.
 - steer is enabled by default in interactive mode: normal input goes into the
   runtime steer path, the current request stops at the next safe boundary, and
   later steer text is appended to the next model request's `input` in order;

{python_codex-0.2.2 → python_codex-0.2.3}/README.md

@@ -144,15 +144,16 @@ pycodex --put @127.0.0.1:5577
 pycodex --put /data/.codex/@127.0.0.1:5577
 pycodex --call SECRET-CALLID@127.0.0.1:5577 "Reply with exactly OK."
 pycodex doctor
-pycodex-ws --listen 0.0.0.0:6007 --board ./board.html
+pycodex-ws --listen 0.0.0.0:6007 --workspace-config ./workspaces.json
+pycodex-ws --listen 0.0.0.0:6007 --workspace-config ./workspaces.json --password 12345
 ```
 
 Current behavior:
 
 - with no argv prompt and a TTY stdin, enter interactive mode
 - with an argv prompt or piped stdin, run a single turn
-- `pycodex-ws` starts the standalone browser workspace with a board pane and a
-  pycodex session pane
+- `pycodex-ws` starts the standalone browser workspace manager and serves each
+  workspace with a board pane and a pycodex session pane
 - interactive mode supports `/exit` and `/quit`
 - interactive mode shows a compact event stream for user-visible phases such as
   tool execution and model follow-up after tool results
@@ -183,6 +184,22 @@ Current behavior:
   non-persisted follow-up session and submits the file contents as the next
   user instruction; this is intended for side-effect follow-ups such as
   Feishu notifications
+- `/link <feishu-email|open_id|chat_id>` attaches the current interactive
+  session to a Feishu card; multiple sessions in the same pycodex process share
+  one Feishu long-connection listener and route card actions by message id
+- `pycodex-ws --workspace-config workspaces.json` serves workspace boards from
+  one process. The JSON file can be either a list or
+  `{"workspaces": [...]}`; each entry uses `board` and `work_dir`, with optional
+  display/URL `id`, and is exposed at `/w/<id>/`. Internally the resolved
+  `board` path is the workspace identity, so adding the same board path twice is
+  rejected even with a different name. Relative `board` and `work_dir` paths
+  resolve from the config file directory. The root path `/` shows a workspaces
+  management page with `add_workspace(name=None, dir="./", board=None)` and
+  `delete(name)` controls; omitted names become `workspace-1`, `workspace-2`,
+  etc. If `board` is omitted when adding a workspace, pycodex assigns a random
+  writable `/tmp/pcws-*.html` board path. Add/delete actions and later
+  session-state saves refresh the JSON file. `--password <value>` enables a
+  password-only login page for workspace pages, APIs, and websocket connections.
 - steer is enabled by default in interactive mode: normal input goes into the
   runtime steer path, the current request stops at the next safe boundary, and
   later steer text is appended to the next model request's `input` in order;

{python_codex-0.2.2 → python_codex-0.2.3}/pycodex/cli.py

@@ -165,6 +165,7 @@ def resolve_prompt_text(prompt_parts: 'Sequence[str]') -> 'str':
 def get_tools(
     runtime_environment: 'typing.Union[AgentRuntimeEnvironment, None]' = None,
     exec_mode: 'bool' = False,
+    cwd: 'typing.Union[str, Path, None]' = None,
 ):
     from .tools import (
         ApplyPatchTool,
@@ -194,8 +195,8 @@ def get_tools(
 
     runtime_environment = runtime_environment or create_agent_runtime_environment()
     registry = Registry()
-    code_mode_manager = CodeModeManager(registry)
-    unified_exec_manager = UnifiedExecManager()
+    code_mode_manager = CodeModeManager(registry, cwd=cwd)
+    unified_exec_manager = UnifiedExecManager(cwd=cwd)
     exec_tool = ExecTool(code_mode_manager)
     wait_tool = WaitTool(code_mode_manager)
     web_search_tool = WebSearchTool()
@@ -211,15 +212,15 @@ def get_tools(
     resume_agent_tool = ResumeAgentTool(runtime_environment.subagent_manager)
     wait_agent_tool = WaitAgentTool(runtime_environment.subagent_manager)
     close_agent_tool = CloseAgentTool(runtime_environment.subagent_manager)
-    apply_patch_tool = ApplyPatchTool()
-    shell_tool = ShellTool()
-    shell_command_tool = ShellCommandTool()
+    apply_patch_tool = ApplyPatchTool(cwd=cwd)
+    shell_tool = ShellTool(cwd=cwd)
+    shell_command_tool = ShellCommandTool(cwd=cwd)
     exec_command_tool = ExecCommandTool(unified_exec_manager)
     write_stdin_tool = WriteStdinTool(unified_exec_manager)
-    grep_files_tool = GrepFilesTool()
+    grep_files_tool = GrepFilesTool(cwd=cwd)
     read_file_tool = ReadFileTool()
     list_dir_tool = ListDirTool()
-    view_image_tool = ViewImageTool()
+    view_image_tool = ViewImageTool(cwd=cwd)
     if exec_mode:
         registry.register(exec_command_tool)
         registry.register(write_stdin_tool)
@@ -258,7 +259,10 @@ def get_tools(
     return registry
 
 
-def get_subagent_tools(runtime_environment: 'typing.Union[AgentRuntimeEnvironment, None]' = None):
+def get_subagent_tools(
+    runtime_environment: 'typing.Union[AgentRuntimeEnvironment, None]' = None,
+    cwd: 'typing.Union[str, Path, None]' = None,
+):
     from .tools import (
         ApplyPatchTool,
         ExecCommandTool,
@@ -272,13 +276,13 @@ def get_subagent_tools(runtime_environment: 'typing.Union[AgentRuntimeEnvironmen
 
     runtime_environment = runtime_environment or create_agent_runtime_environment()
     registry = Registry()
-    unified_exec_manager = UnifiedExecManager()
+    unified_exec_manager = UnifiedExecManager(cwd=cwd)
     registry.register(ExecCommandTool(unified_exec_manager))
     registry.register(WriteStdinTool(unified_exec_manager))
     registry.register(UpdatePlanTool(runtime_environment.plan_store))
-    registry.register(ApplyPatchTool())
+    registry.register(ApplyPatchTool(cwd=cwd))
     registry.register(WebSearchTool())
-    registry.register(ViewImageTool())
+    registry.register(ViewImageTool(cwd=cwd))
     return registry
 
 
@@ -290,8 +294,10 @@ def build_agent(
     session_mode: 'CliSessionMode' = "exec",
     collaboration_mode: 'CollaborationMode' = DEFAULT_COLLABORATION_MODE,
     extra_contextual_user_messages: 'typing.Iterable[str]' = (),
+    cwd: 'typing.Union[str, Path, None]' = None,
 ) -> 'Agent':
     config_path = str(config_path)
+    resolved_cwd = Path(cwd or Path.cwd()).resolve()
     context_manager = ContextManager.from_codex_config(
         config_path,
         profile,
@@ -299,6 +305,7 @@ def build_agent(
         collaboration_mode=collaboration_mode,
         include_collaboration_instructions=session_mode == "tui",
         extra_contextual_user_messages=extra_contextual_user_messages,
+        cwd=resolved_cwd,
     )
     session_id = getattr(client, "_session_id", None) or uuid7_string()
     if hasattr(client, "_session_id"):
@@ -309,6 +316,7 @@ def build_agent(
         base_instructions_override=system_prompt,
         include_collaboration_instructions=False,
         extra_contextual_user_messages=extra_contextual_user_messages,
+        cwd=resolved_cwd,
     )
     runtime_environment = create_agent_runtime_environment()
     runtime_environment.request_user_input_manager.set_handler(None)
@@ -343,7 +351,7 @@ def build_agent(
             )
             sub_agent = Agent(
                 nested_client,
-                get_subagent_tools(subagent_agent_runtime_environment),
+                get_subagent_tools(subagent_agent_runtime_environment, cwd=resolved_cwd),
                 subagent_context_manager,
                 initial_history=tuple(initial_history),
                 runtime_environment=subagent_agent_runtime_environment,
@@ -357,7 +365,7 @@ def build_agent(
     )
     return Agent(
         client,
-        get_tools(runtime_environment, exec_mode=True),
+        get_tools(runtime_environment, exec_mode=True, cwd=resolved_cwd),
         context_manager,
         rollout_recorder=rollout_recorder,
         runtime_environment=runtime_environment,

{python_codex-0.2.2 → python_codex-0.2.3}/pycodex/context.py

@@ -150,8 +150,9 @@ class ContextManager:
         include_skills_instructions: 'bool' = True,
         network_access: 'str' = "enabled",
         extra_contextual_user_messages: 'typing.Iterable[str]' = (),
+        cwd: 'typing.Union[str, Path, None]' = None,
     ) -> 'None':
-        self.cwd = Path.cwd().resolve()
+        self.cwd = Path(cwd or Path.cwd()).resolve()
         self._shell = get_shell_name()
         self._current_date = datetime.now().date().isoformat()
         self._timezone_name = get_timezone_name()
@@ -193,6 +194,7 @@ class ContextManager:
         include_skills_instructions: 'bool' = True,
         network_access: 'str' = "enabled",
         extra_contextual_user_messages: 'typing.Iterable[str]' = (),
+        cwd: 'typing.Union[str, Path, None]' = None,
     ) -> 'ContextManager':
         config = ContextConfig.from_codex_config(config_path, profile)
         return cls(
@@ -204,6 +206,7 @@ class ContextManager:
             include_skills_instructions=include_skills_instructions,
             network_access=network_access,
             extra_contextual_user_messages=extra_contextual_user_messages,
+            cwd=cwd,
         )
 
     @property

{python_codex-0.2.2 → python_codex-0.2.3}/pycodex/feishu_link.py

@@ -224,7 +224,8 @@ class _FeishuCardActionListener:
         self.domain = card.domain
         self.encrypt_key = card.encrypt_key
         self.verification_token = card.verification_token
-        self.link = None
+        self._links = {}
+        self._links_lock = threading.Lock()
         self._async_thread = _AsyncLoopThread()
         self._thread = None
         self._client = None
@@ -250,14 +251,29 @@ class _FeishuCardActionListener:
         self._thread.start()
 
     def register(self, link: PycodexRuntimeLink) -> None:
-        self.link = link
+        message_id = str(getattr(link, "message_id", "") or "").strip()
+        if not message_id:
+            raise RuntimeError("Feishu linked card message_id is required")
+        with self._links_lock:
+            self._links[message_id] = link
 
     def unregister(self, link: PycodexRuntimeLink) -> None:
-        if self.link is link:
-            self.link = None
+        message_id = str(getattr(link, "message_id", "") or "").strip()
+        with self._links_lock:
+            if message_id and self._links.get(message_id) is link:
+                del self._links[message_id]
+                return
+            stale_ids = [
+                registered_id
+                for registered_id, registered_link in self._links.items()
+                if registered_link is link
+            ]
+            for registered_id in stale_ids:
+                del self._links[registered_id]
 
     def empty(self) -> bool:
-        return self.link is None
+        with self._links_lock:
+            return not self._links
 
     def stop(self) -> None:
         self._stop_requested.set()
@@ -329,16 +345,9 @@ class _FeishuCardActionListener:
 
     def _handle_card_action(self, event) -> 'typing.Dict[str, object]':
         try:
-            link = self.link
-            if link is None or link._detached:
-                return {
-                    "toast": {
-                        "type": "warning",
-                        "content": "pycodex is detached.",
-                    }
-                }
             message_id = _event_message_id(event)
-            if message_id and message_id != link.message_id:
+            link = self._resolve_link(message_id)
+            if link is None or link._detached:
                 return {
                     "toast": {
                         "type": "warning",
@@ -355,6 +364,15 @@ class _FeishuCardActionListener:
                 }
             }
 
+    def _resolve_link(self, message_id):
+        message_id = str(message_id or "").strip()
+        with self._links_lock:
+            if message_id:
+                return self._links.get(message_id)
+            if len(self._links) == 1:
+                return next(iter(self._links.values()))
+            return None
+
 
 def _event_message_id(event) -> "typing.Union[str, None]":
     event_data = getattr(event, "event", None)

{python_codex-0.2.2 → python_codex-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "python-codex"
-version = "0.2.2"
+version = "0.2.3"
 description = "A minimal Python extraction of Codex's main agent loop"
 readme = "README.md"
 requires-python = ">=3.6.2"
@@ -45,7 +45,10 @@ default-groups = []
 
 [tool.hatch.build.targets.wheel]
 packages = ["pycodex", "responses_server", "workspace_server"]
-artifacts = ["workspace_server/workspace.html"]
+artifacts = [
+    "workspace_server/workspace.html",
+    "workspace_server/workspaces.html",
+]
 
 [tool.hatch.build.targets.sdist]
 exclude = [".venv*"]

{python_codex-0.2.2 → python_codex-0.2.3}/tests/test_cli.py

@@ -975,6 +975,23 @@ def test_get_tools_exec_mode_matches_codex_exec_subset() -> 'None':
     )
 
 
+@pytest.mark.asyncio
+async def test_get_tools_exec_mode_uses_explicit_cwd(tmp_path) -> 'None':
+    registry = get_tools(exec_mode=True, cwd=tmp_path)
+    tool = registry.get_tool("exec_command")
+    assert tool is not None
+
+    output = await tool.run(
+        None,
+        {
+            "cmd": "pwd",
+            "yield_time_ms": 1000,
+        },
+    )
+
+    assert str(tmp_path) in str(output)
+
+
 def _tool_payload_by_name(registry: 'ToolRegistry') -> 'typing.Dict[str, typing.Dict[str, object]]':
     payloads: 'typing.Dict[str, typing.Dict[str, object]]' = {}
     for payload in [spec.serialize() for spec in registry.model_visible_specs()]:

{python_codex-0.2.2 → python_codex-0.2.3}/tests/test_context.py

@@ -86,6 +86,18 @@ def test_context_manager_reads_auto_compact_limit_from_codex_config(tmp_path) ->
     assert manager.resolve_auto_compact_token_limit() == 12345
 
 
+def test_context_manager_accepts_explicit_cwd(tmp_path, monkeypatch) -> 'None':
+    explicit_cwd = tmp_path / "workspace"
+    explicit_cwd.mkdir()
+    other_cwd = tmp_path / "other"
+    other_cwd.mkdir()
+    monkeypatch.chdir(other_cwd)
+
+    manager = ContextManager(cwd=explicit_cwd)
+
+    assert manager.cwd == explicit_cwd.resolve()
+
+
 @pytest.mark.parametrize(
     "model",
     ["step-3.5-flash", "step-3.5-flash-2603", "step-3.7-flash"],

{python_codex-0.2.2 → python_codex-0.2.3}/tests/test_feishu_link.py

@@ -88,18 +88,34 @@ async def _forever():
         await asyncio.sleep(3600)
 
 
-def test_feishu_listener_tracks_one_active_link() -> None:
+def test_feishu_listener_tracks_active_links_by_message_id() -> None:
     listener = _FeishuCardActionListener(PycodexCard(app_id="app", app_secret="secret"))
     first = _Object(message_id="om_first")
     second = _Object(message_id="om_second")
 
     listener.register(first)
-    assert listener.link is first
+    assert listener._resolve_link("om_first") is first
+    listener.register(second)
+    assert listener._resolve_link("om_first") is first
+    assert listener._resolve_link("om_second") is second
+
     listener.unregister(first)
-    assert listener.link is None
+    assert listener._resolve_link("om_first") is None
+    assert listener._resolve_link("om_second") is second
 
-    listener.register(second)
-    assert listener.link is second
+    listener.unregister(second)
+    assert listener.empty()
+
+
+def test_feishu_listener_unregisters_link_if_message_id_changes() -> None:
+    listener = _FeishuCardActionListener(PycodexCard(app_id="app", app_secret="secret"))
+    link = _Object(message_id="om_first")
+
+    listener.register(link)
+    link.message_id = "om_second"
+    listener.unregister(link)
+
+    assert listener.empty()
 
 
 def test_feishu_listener_stops_when_last_link_is_released(monkeypatch) -> None:
@@ -112,7 +128,29 @@ def test_feishu_listener_stops_when_last_link_is_released(monkeypatch) -> None:
 
     _release_feishu_listener(listener, link)
 
-    assert listener.link is None
+    assert listener.empty()
+    assert stopped == [True]
+    assert feishu_link._LISTENER is None
+
+
+def test_feishu_listener_does_not_stop_until_all_links_are_released(monkeypatch) -> None:
+    listener = _FeishuCardActionListener(PycodexCard(app_id="app", app_secret="secret"))
+    first = _Object(message_id="om_first")
+    second = _Object(message_id="om_second")
+    stopped = []
+    listener.stop = lambda: stopped.append(True)
+    listener.register(first)
+    listener.register(second)
+    monkeypatch.setattr(feishu_link, "_LISTENER", listener)
+
+    _release_feishu_listener(listener, first)
+
+    assert stopped == []
+    assert feishu_link._LISTENER is listener
+    assert listener._resolve_link("om_second") is second
+
+    _release_feishu_listener(listener, second)
+
     assert stopped == [True]
     assert feishu_link._LISTENER is None
 
@@ -131,6 +169,60 @@ def test_feishu_listener_relink_creates_fresh_listener(monkeypatch) -> None:
     assert feishu_link._LISTENER is second
 
 
+def test_feishu_listener_routes_card_action_by_message_id(monkeypatch) -> None:
+    listener = _FeishuCardActionListener(PycodexCard(app_id="app", app_secret="secret"))
+    first = _Object(
+        message_id="om_first",
+        _detached=False,
+        card=_Object(parse_action=lambda event: {"action": "send", "prompt": "first"}),
+    )
+    second = _Object(
+        message_id="om_second",
+        _detached=False,
+        card=_Object(parse_action=lambda event: {"action": "send", "prompt": "second"}),
+    )
+    submitted = []
+
+    async def submit(action):
+        submitted.append(action["prompt"])
+        return {"toast": {"type": "info", "content": action["prompt"]}}
+
+    first._submit = submit
+    second._submit = submit
+
+    def run_coro(coro):
+        loop = asyncio.new_event_loop()
+        try:
+            return loop.run_until_complete(coro)
+        finally:
+            loop.close()
+
+    listener._async_thread.run = run_coro
+
+    listener.register(first)
+    listener.register(second)
+
+    result = listener._handle_card_action(_event("om_second"))
+
+    assert submitted == ["second"]
+    assert result["toast"]["content"] == "second"
+
+
+def test_feishu_listener_rejects_unknown_card_action_message_id() -> None:
+    listener = _FeishuCardActionListener(PycodexCard(app_id="app", app_secret="secret"))
+    listener.register(_Object(message_id="om_first", _detached=False))
+    listener.register(_Object(message_id="om_second", _detached=False))
+
+    result = listener._handle_card_action(_event("om_stale"))
+
+    assert result == {
+        "toast": {
+            "type": "warning",
+            "content": "pycodex is detached.",
+        }
+    }
+
+
 def test_feishu_listener_replaces_running_sdk_module_loop(monkeypatch) -> None:
     client_module = types.ModuleType("lark_oapi.ws.client")
     started_loops = []