pycodex-ws 0.4.7__tar.gz → 0.4.8__tar.gz

{pycodex_ws-0.4.7 → pycodex_ws-0.4.8}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: pycodex-ws
-Version: 0.4.7
+Version: 0.4.8
 Summary: Browser workspace and optional Feishu integration for python-codex
 License-File: LICENSE
 Requires-Python: >=3.7
 Requires-Dist: pillow>=9.0.0
-Requires-Dist: python-codex==0.4.7
+Requires-Dist: python-codex==0.4.8
 Requires-Dist: websockets<16,>=11
 Description-Content-Type: text/markdown
 
@@ -87,14 +87,34 @@ Use a filename prefix and a separate Canvas switch in `workspaces.json`:
 ```
 
 Start it with `pycodex-ws --workspace-config workspaces.json`.
+Sessions appear in a sidebar on the right. Collapsing it hides the titles and
+keeps a clickable column of status dots: running sessions pulse, finished
+sessions show a steady green dot, and unread replies retain their red marker.
+Hover a dot to see its title, or use the sidebar button to expand the titles.
+On narrow screens the expanded sidebar overlays the conversation and returns
+to its collapsed state after selecting or creating a session. On phones the
+collapsed sidebar and chat header are hidden. A compact floating control in
+the upper-right corner shows clickable status dots vertically, plus buttons
+to expand the session list or switch between chat and the board. Both layouts use
+smooth transitions and respect the system's reduced-motion preference.
+Session renaming and closing remain available in the expanded sidebar.
 Relative paths resolve from the configuration directory. This example uses
-`demo.pycodex-ws.json` for session titles and rollout references,
+`demo.pycodex-ws.json` for session titles, directories and rollout references,
 `demo.pycodex-views.json` for file views, and `demo.html` for Canvas.
 All suffixes are appended to the complete prefix, including any dots.
 The resolved `state_path` identifies the workspace; two entries cannot share it.
 Creating a workspace through the management page or API without a prefix
 generates a `/tmp/pcws-*` prefix and saves it in the configuration.
 
+Each session starts in `work_dir`. Use `/cd <directory>` while idle to change
+only that session, or `/cd` to show its directory. Relative paths and `~` work;
+enter paths containing spaces without quotes. A small folder indicator inside
+the composer appears only when the directory differs from `work_dir`; hover
+for the full path. Directories are restored after server restart, even for empty sessions. Tools,
+AGENTS instructions and relative chat/Canvas file links use the selected
+session's directory. Existing processes keep their original directory.
+Canvas and workspace state files retain their configured locations.
+
 The router directory collects unread workspace shortcuts and their device names
 in a distinct Unread panel at the top. Read workspaces leave that panel.
 Drag a handle in Online devices to reorder devices; both lists share the saved

{pycodex_ws-0.4.7 → pycodex_ws-0.4.8}/README.md

@@ -76,14 +76,34 @@ Use a filename prefix and a separate Canvas switch in `workspaces.json`:
 ```
 
 Start it with `pycodex-ws --workspace-config workspaces.json`.
+Sessions appear in a sidebar on the right. Collapsing it hides the titles and
+keeps a clickable column of status dots: running sessions pulse, finished
+sessions show a steady green dot, and unread replies retain their red marker.
+Hover a dot to see its title, or use the sidebar button to expand the titles.
+On narrow screens the expanded sidebar overlays the conversation and returns
+to its collapsed state after selecting or creating a session. On phones the
+collapsed sidebar and chat header are hidden. A compact floating control in
+the upper-right corner shows clickable status dots vertically, plus buttons
+to expand the session list or switch between chat and the board. Both layouts use
+smooth transitions and respect the system's reduced-motion preference.
+Session renaming and closing remain available in the expanded sidebar.
 Relative paths resolve from the configuration directory. This example uses
-`demo.pycodex-ws.json` for session titles and rollout references,
+`demo.pycodex-ws.json` for session titles, directories and rollout references,
 `demo.pycodex-views.json` for file views, and `demo.html` for Canvas.
 All suffixes are appended to the complete prefix, including any dots.
 The resolved `state_path` identifies the workspace; two entries cannot share it.
 Creating a workspace through the management page or API without a prefix
 generates a `/tmp/pcws-*` prefix and saves it in the configuration.
 
+Each session starts in `work_dir`. Use `/cd <directory>` while idle to change
+only that session, or `/cd` to show its directory. Relative paths and `~` work;
+enter paths containing spaces without quotes. A small folder indicator inside
+the composer appears only when the directory differs from `work_dir`; hover
+for the full path. Directories are restored after server restart, even for empty sessions. Tools,
+AGENTS instructions and relative chat/Canvas file links use the selected
+session's directory. Existing processes keep their original directory.
+Canvas and workspace state files retain their configured locations.
+
 The router directory collects unread workspace shortcuts and their device names
 in a distinct Unread panel at the top. Read workspaces leave that panel.
 Drag a handle in Online devices to reorder devices; both lists share the saved

{pycodex_ws-0.4.7 → pycodex_ws-0.4.8}/pycodex_router/browser.py

@@ -8,7 +8,7 @@ from starlette.exceptions import HTTPException
 from starlette.requests import HTTPConnection
 from starlette.responses import JSONResponse, RedirectResponse
 
-from .protocol import route_path
+from .protocol import agent_api_request, route_path
 
 
 def request_origin(connection):
@@ -77,6 +77,11 @@ class BrowserAccess:
                 raise HTTPException(
                     403, "Cross-origin router requests are not allowed."
                 )
+            device = (
+                self.router.authenticated_device(connection)
+                if agent_api_request(scope) else None
+            )
+            scope["pycodex.agent_access"] = device is not None
             await self.app(scope, receive, secured_send)
         except HTTPException as exc:
             if scope["type"] == "websocket":

{pycodex_ws-0.4.7 → pycodex_ws-0.4.8}/pycodex_router/client.py

@@ -7,7 +7,9 @@ from contextlib import asynccontextmanager
 from websockets.exceptions import ConnectionClosed, InvalidHandshake, InvalidStatusCode
 from websockets.legacy.client import connect
 
-from .protocol import decode, device_id, encode, parse_target, send_event, tunnel_url
+from .protocol import (
+    decode, device_id, encode, normalize_api_url, parse_target, send_event, tunnel_url,
+)
 
 
 class NodeIdInUse(Exception):
@@ -37,6 +39,7 @@ class RouterClient:
         self.refresh_seconds = refresh_seconds
         self.reconnect_seconds = reconnect_seconds
         self.connected = False
+        self.api_url = None
         self._task = None
         self._channels = set()
         self._requests = set()
@@ -89,6 +92,7 @@ class RouterClient:
                 failure = exc
             finally:
                 self.connected = False
+                self.api_url = None
 
             try:
                 await self._close_channels()
@@ -133,6 +137,8 @@ class RouterClient:
             raise NodeIdInUse("router node id is still registered")
         if reply.get("type") != "registered" or reply.get("id") != self.node_id:
             raise ValueError("unexpected router registration response")
+        api_url = reply.get("api_url")
+        self.api_url = normalize_api_url(api_url) if api_url is not None else None
 
     async def _session(self, channel):
         async def receive_requests():
@@ -187,6 +193,7 @@ class RouterClient:
                     scope = opening["scope"]
                     if scope["type"] not in {"http", "websocket"}:
                         raise ValueError("unsupported router request type")
+                    scope["pycodex.agent_access"] = opening.get("agent_access") is True
 
                     async def receive():
                         try:

{pycodex_ws-0.4.7 → pycodex_ws-0.4.8}/pycodex_router/protocol.py

@@ -8,6 +8,29 @@ from http.cookies import SimpleCookie
 from urllib.parse import urlsplit, urlunsplit
 
 
+def normalize_api_url(value):
+    """A public HTTP base URL, without credentials or request parameters."""
+    try:
+        if not isinstance(value, str) or any(
+            char.isspace() or ord(char) < 32 or char in "\\?#" for char in value
+        ):
+            raise ValueError()
+        parsed = urlsplit(value)
+        if (
+            parsed.scheme not in {"http", "https"}
+            or not parsed.hostname
+            or parsed.username is not None
+            or parsed.password is not None
+        ):
+            raise ValueError()
+        parsed.port
+    except ValueError:
+        raise ValueError(
+            "API URL must be an http(s) URL without credentials, query or fragment"
+        ) from None
+    return value.rstrip("/")
+
+
 def device_id(identity_key):
     if not isinstance(identity_key, str) or not re.fullmatch(
         "[0-9a-f]{64}", identity_key
@@ -23,6 +46,25 @@ def route_path(scope):
     return path[len(root) :] if root and path.startswith(root + "/") else path
 
 
+def agent_api_request(scope):
+    """The existing HTTP discovery, message and polling endpoints."""
+    if scope["type"] != "http":
+        return False
+    match = re.fullmatch(
+        r"(?:/n/[a-z2-7]{52})?(?:/w/[^/]+)?/api/(workspaces|sessions|session|session/message)",
+        route_path(scope),
+    )
+    return match is not None and scope["method"] == (
+        "POST" if match.group(1) == "session/message" else "GET"
+    )
+
+
+def trusted_agent_request(scope):
+    # This flag comes only from the private socket or an authenticated tunnel
+    # envelope, never from HTTP headers or the forwarded ASGI scope.
+    return scope.get("pycodex.agent_access") is True and agent_api_request(scope)
+
+
 def tunnel_url(target, endpoint):
     parsed = urlsplit(target if "://" in target else "ws://" + target)
     schemes = {"http": "ws", "https": "wss", "ws": "ws", "wss": "wss"}

{pycodex_ws-0.4.7 → pycodex_ws-0.4.8}/pycodex_router/server.py

@@ -30,9 +30,11 @@ from .protocol import (
     decode,
     device_id,
     encode,
+    normalize_api_url,
     request_scope,
     response_headers,
     send_event,
+    trusted_agent_request,
 )
 
 
@@ -154,7 +156,11 @@ class Router:
         max_connections=64,
         registration_key=None,
         aliases_path=None,
+        api_url=None,
+        api_port=None,
     ):
+        self.api_url = normalize_api_url(api_url) if api_url is not None else None
+        self.api_port = api_port
         self.registration_key = (
             _base58_encode(os.urandom(16))
             if registration_key is None
@@ -257,6 +263,18 @@ class Router:
         await websocket.accept()
         return True
 
+    def authenticated_device(self, connection):
+        if "origin" in connection.headers or "sec-fetch-site" in connection.headers:
+            return None
+        authorization = connection.headers.get("authorization", "")
+        if not authorization.startswith("Bearer "):
+            return None
+        try:
+            node_id = device_id(authorization[7:])
+        except ValueError:
+            return None
+        return self.nodes.get(node_id)
+
     async def control(self, websocket):
         if not await self.accept_tunnel(websocket):
             return
@@ -295,7 +313,17 @@ class Router:
                 aliases[node_id] = ""
                 self._save_aliases(aliases)
             self.nodes[node_id] = node
-            await websocket.send_text(encode({"type": "registered", "id": node_id}))
+            api_url = self.api_url
+            if api_url is None and self.api_port is not None:
+                host = websocket.url.hostname
+                if ":" in host:
+                    host = "[" + host + "]"
+                api_url = normalize_api_url(
+                    "http://{0}:{1}".format(host, self.api_port)
+                )
+            await websocket.send_text(encode({
+                "type": "registered", "id": node_id, "api_url": api_url,
+            }))
             while True:
                 message = await control_message(websocket)
                 if message.get("type") != "workspaces":
@@ -376,8 +404,12 @@ class Router:
     async def proxy(self, scope, receive, send):
         connection = HTTPConnection(scope)
         blocked = connection.client.host in self.blocked_ips
-        if blocked or not _auth_cookie_matches(
-            self.browser_token, connection.cookies.get("pycodex_router_auth")
+        agent_access = trusted_agent_request(scope)
+        if blocked or not (
+            agent_access
+            or _auth_cookie_matches(
+                self.browser_token, connection.cookies.get("pycodex_router_auth")
+            )
         ):
             await require_login(scope, receive, send)
             return
@@ -423,6 +455,7 @@ class Router:
                         {
                             "type": "open",
                             "scope": request_scope(scope),
+                            "agent_access": agent_access,
                         }
                     )
                 )
@@ -488,8 +521,12 @@ def create_app(
     max_connections=64,
     registration_key=None,
     aliases_path=None,
+    api_url=None,
+    api_port=None,
 ):
-    router = Router(connect_timeout, max_connections, registration_key, aliases_path)
+    router = Router(
+        connect_timeout, max_connections, registration_key, aliases_path, api_url, api_port
+    )
 
     async def index(request):
         return HTMLResponse(
@@ -568,6 +605,14 @@ def build_parser():
     parser.add_argument(
         "--tunnel-listen", default="0.0.0.0:6000", help="Device host:port."
     )
+    parser.add_argument(
+        "--api-url",
+        help=(
+            "Public browser/API base URL advertised to devices, including any proxy "
+            "path prefix. Defaults to the device connection hostname and browser "
+            "HTTP port; set this for HTTPS, reverse proxies or port forwarding."
+        ),
+    )
     parser.add_argument(
         "--password",
         required=True,
@@ -583,6 +628,11 @@ def main(argv=None):
     args = parser.parse_args(argv)
     if not args.password:
         parser.error("--password must not be empty")
+    if args.api_url is not None:
+        try:
+            args.api_url = normalize_api_url(args.api_url)
+        except ValueError as exc:
+            parser.error(str(exc))
     addresses = [parse_listen(args.listen), parse_listen(args.tunnel_listen)]
     if addresses[0][1] != 0 and addresses[0][1] == addresses[1][1]:
         parser.error("browser and device listeners must use different ports")
@@ -592,6 +642,7 @@ def main(argv=None):
         args.password,
         registration_key=load_registration_key(key_path),
         aliases_path=codex_home / "router-aliases.json",
+        api_url=args.api_url,
     )
     tunnel_app = create_tunnel_app(app.state.router)
     sockets = []
@@ -652,6 +703,7 @@ def main(argv=None):
                 config = listener
         if sockets[0].getsockname()[1] == sockets[1].getsockname()[1]:
             raise ValueError("browser and device listeners must use different ports")
+        app.state.router.api_port = sockets[0].getsockname()[1]
         RouterServer(config).run(sockets=sockets)
     finally:
         for listener_socket in sockets:

{pycodex_ws-0.4.7 → pycodex_ws-0.4.8}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pycodex-ws"
-version = "0.4.7"
+version = "0.4.8"
 description = "Browser workspace and optional Feishu integration for python-codex"
 readme = "README.md"
 requires-python = ">=3.7"
 dependencies = [
-    "python-codex==0.4.7",
+    "python-codex==0.4.8",
     "pillow>=9.0.0",
     "websockets>=11,<16",
 ]

pycodex_ws-0.4.8/workspace_server/agent_access.py

@@ -0,0 +1,66 @@
+"""Same-user HTTP access to existing local and registered-device APIs."""
+
+from urllib.parse import unquote, urlsplit, urlunsplit
+
+import requests
+from starlette.concurrency import run_in_threadpool
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+
+from pycodex_router.protocol import agent_api_request
+
+
+class AgentSocketAccess:
+    def __init__(self, app):
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        socket_path = getattr(self.app.state, "agent_socket_path", None)
+        # Uvicorn gets this address from the socket, independently of HTTP headers.
+        if (
+            scope["type"] != "http" or socket_path is None
+            or scope["server"] not in (None, (socket_path, None))
+        ):
+            await self.app(scope, receive, send)
+            return
+        scope = dict(scope)
+        scope["pycodex.agent_access"] = True
+        if not scope["path"].startswith("/router/"):
+            await self.app(scope, receive, send)
+            return
+        client = getattr(self.app.state, "router_client", None)
+        if client is None or not client.connected or client.api_url is None:
+            await JSONResponse({"error": "router API is unavailable"}, 503)(scope, receive, send)
+            return
+        remote = urlsplit(client.api_url)
+        scope["path"] = scope["path"][len("/router"):]
+        scope["root_path"] = unquote(remote.path)
+        if not scope["path"].startswith(scope["root_path"] + "/") or not agent_api_request(scope):
+            await JSONResponse({"error": "not a session API"}, 403)(scope, receive, send)
+            return
+        url = urlunsplit((
+            remote.scheme, remote.netloc,
+            scope["raw_path"][len(b"/router"):].decode("ascii"),
+            scope["query_string"].decode("ascii"), "",
+        ))
+        body = await Request(scope, receive).body()
+
+        def forward():
+            with requests.Session() as session:
+                session.trust_env = False
+                result = session.request(
+                    scope["method"], url, data=body,
+                    headers={"Authorization": "Bearer " + client._identity_key,
+                             "Content-Type": "application/json"},
+                    allow_redirects=False, timeout=(10, 30),
+                )
+                return Response(
+                    result.content, result.status_code,
+                    media_type=result.headers.get("content-type", "application/json"),
+                )
+
+        try:
+            response = await run_in_threadpool(forward)
+        except requests.RequestException:
+            response = JSONResponse({"error": "router API is unavailable"}, 503)
+        await response(scope, receive, send)

{pycodex_ws-0.4.7 → pycodex_ws-0.4.8}/workspace_server/app.py

@@ -74,7 +74,9 @@ from pycodex.utils.event_helpers import (
 )
 from pycodex.utils.session_persist import load_display_history
 from pycodex_ws import build_runtime
+from pycodex_router.protocol import trusted_agent_request
 
+from .runtime_info import runtime_info_prompt
 from .workspace_views import WorkspaceViewOpener
 from .workspaces import (
     WorkspaceDefinition,
@@ -201,6 +203,7 @@ class WebSessionView:
         self._title = ""
         self._last_final_id = ""
         self._model = "pycodex"
+        self._cwd = ""
         self._rollout_path = ""
         self._recorded_rollout_path = ""
         self._input_request = None
@@ -326,6 +329,7 @@ class WebSessionView:
                 "status_kind": "spinner" if self._spinner_status else "idle",
                 "spinner": self._spinner_status,
                 "model": self._model,
+                "cwd": self._cwd,
                 "rollout_path": self._rollout_path,
                 "recorded_rollout_path": self._recorded_rollout_path,
                 "input_request": _json_safe(self._input_request),
@@ -344,6 +348,7 @@ class WebSessionView:
         with self._lock:
             return {
                 "model": self._model,
+                "cwd": self._cwd,
                 "running": bool(self._spinner_status),
                 "last_final_id": self._last_final_id,
                 "spinner": self._spinner_status,
@@ -357,6 +362,7 @@ class WebSessionView:
         if isinstance(event, SessionStateEvent):
             state = event.state
             self._model = state["model"]
+            self._cwd = state["cwd"]
             self._rollout_path = state["rollout_path"]
             self._recorded_rollout_path = state["recorded_rollout_path"]
             self._input_request = state["input_request"]
@@ -714,8 +720,14 @@ class WorkspaceInteractiveSession:
         return self.view.snapshot()["rollout_path"]
 
     async def restore_from_rollout(
-        self, rollout_path: str, title: str = "", fork: bool = False
+        self,
+        rollout_path: str,
+        title: str = "",
+        fork: bool = False,
+        cwd: "typing.Optional[str]" = None,
     ) -> None:
+        if cwd is not None:
+            self.runtime.set_cwd(cwd)
         if rollout_path:
             self.runtime.resume(rollout_path, title)
             if fork:
@@ -840,7 +852,11 @@ class ThreadedWorkspaceInteractiveSession:
         return self._session.rollout_path()
 
     async def restore_from_rollout(
-        self, rollout_path: str, title: str = "", fork: bool = False
+        self,
+        rollout_path: str,
+        title: str = "",
+        fork: bool = False,
+        cwd: "typing.Optional[str]" = None,
     ) -> None:
         session = self._session
         loop = self._worker_loop
@@ -848,7 +864,7 @@ class ThreadedWorkspaceInteractiveSession:
             return
 
         future = asyncio.run_coroutine_threadsafe(
-            session.restore_from_rollout(rollout_path, title=title, fork=fork),
+            session.restore_from_rollout(rollout_path, title=title, fork=fork, cwd=cwd),
             loop,
         )
         await asyncio.wrap_future(future)
@@ -997,7 +1013,7 @@ def create_multi_workspace_app(
 
     async def workspace_session(request: Request) -> JSONResponse:
         entry = _workspace_entry_or_404(registry, request.path_params["workspace_id"])
-        return _session_response(entry.manager, request.query_params.get("session_id"))
+        return _session_response(entry.manager, request, entry.definition.workspace_id)
 
     async def workspace_message(request: Request) -> JSONResponse:
         payload = await _json_object_body(request)
@@ -1119,7 +1135,7 @@ def _install_auth(
         root = request.scope.get("root_path", "")
         if root and path.startswith(root + "/"):
             path = path[len(root):]
-        if path in {"/favicon.ico", "/login"} or _auth_cookie_matches(
+        if path in {"/favicon.ico", "/login"} or trusted_agent_request(request.scope) or _auth_cookie_matches(
             token,
             request.cookies.get(cookie_name),
         ):
@@ -1398,7 +1414,7 @@ def _install_workspace_routes(
         return _read_session_response(manager, request.path_params["session_id"], payload)
 
     async def session(request: Request) -> JSONResponse:
-        return _session_response(manager, request.query_params.get("session_id"))
+        return _session_response(manager, request)
 
     async def message(request: Request) -> JSONResponse:
         payload = await _json_object_body(request)
@@ -1454,10 +1470,17 @@ def _open_view_response(
     manager: WorkspaceSessionManager, work_dir: Path, payload: "typing.Dict[str, object]"
 ) -> JSONResponse:
     try:
+        session_id = payload.get("session_id")
+        if session_id is not None:
+            if not isinstance(session_id, str) or not session_id:
+                raise ValueError("session_id must be a nonempty string")
+            work_dir = Path(manager.get(session_id).summary()["cwd"])
         view = WorkspaceViewOpener(manager.views, work_dir).open(
             payload.get("href"), payload.get("src_path")
         )
         views = manager.views.list_views()
+    except KeyError:
+        raise HTTPException(status_code=404, detail="session not found")
     except (OSError, ValueError, subprocess.TimeoutExpired) as error:
         raise HTTPException(status_code=400, detail=str(error))
     return JSONResponse(
@@ -1623,20 +1646,28 @@ async def _delete_session_response(
 
 def _session_response(
     manager: "WorkspaceSessionManager",
-    session_id: "typing.Union[str, None]" = None,
+    request: Request,
+    workspace_id: "typing.Union[str, None]" = None,
 ) -> JSONResponse:
     try:
-        resolved_id = manager.resolve_session_id(session_id)
+        resolved_id = manager.resolve_session_id(request.query_params.get("session_id"))
         link = manager.get(resolved_id)
     except KeyError:
         raise HTTPException(status_code=404, detail="session not found")
-    return JSONResponse(
-        {
-            "session_id": resolved_id,
-            "sessions": manager.list_sessions(),
-            "snapshot": session_snapshot(link),
-        }
-    )
+    payload = {
+        "session_id": resolved_id,
+        "sessions": manager.list_sessions(),
+        "snapshot": session_snapshot(link),
+    }
+    if request.query_params.get("runtime_info") == "true":
+        state = request.app.state
+        payload["runtime_info"] = runtime_info_prompt(
+            resolved_id, link.summary(), workspace_id,
+            getattr(state, "local_api_url", None),
+            getattr(state, "router_client", None),
+            getattr(state, "agent_socket_path", None),
+        )
+    return JSONResponse(payload, headers={"Cache-Control": "no-store"})
 
 
 async def _message_response(
@@ -1959,7 +1990,7 @@ def _build_workspace_entry(
             profile=args.profile,
             system_prompt=args.system_prompt,
             extra_contextual_user_messages=(
-                [_workspace_context_text(definition.board_path, definition.work_dir)]
+                [_workspace_context_text(definition.board_path)]
                 if definition.board_path is not None
                 else []
             ),
@@ -1986,10 +2017,7 @@ def _build_workspace_entry(
     )
 
 
-def _workspace_context_text(
-    board_path: Path,
-    work_dir: "typing.Union[Path, None]",
-) -> str:
+def _workspace_context_text(board_path: Path) -> str:
     return (
         "Current workspace Canvas file: {0}. "
         "Changes you make to this HTML file are shown to the user in real time. "
@@ -1999,26 +2027,7 @@ def _workspace_context_text(
         "and diff:left..right. Append #L42 to select a file or left-side line, "
         "or #R42 for the right side of a diff. "
         "Use workspace://canvas to return to the live Canvas."
-    ).format(_format_board_path_for_prompt(board_path, work_dir=work_dir))
-
-
-def _format_board_path_for_prompt(
-    board_path: Path,
-    work_dir: "typing.Union[Path, None]" = None,
-) -> str:
-    resolved = board_path.resolve()
-    try:
-        relative = os.path.relpath(
-            str(resolved),
-            str(Path(work_dir or Path.cwd()).resolve()),
-        )
-    except ValueError:
-        return str(resolved)
-    if relative == ".":
-        return "."
-    if relative.startswith(".."):
-        return str(resolved)
-    return "./{0}".format(relative)
+    ).format(board_path.resolve())
 
 
 def _render_workspace_shell(