flowpad 0.2.89__tar.gz → 0.2.91__tar.gz

{flowpad-0.2.89 → flowpad-0.2.91}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowpad
-Version: 0.2.89
+Version: 0.2.91
 Summary: A local-first AI development environment powered by Claude Code
 Author-email: Langware Labs <eran@langware.ai>
 Project-URL: Homepage, https://flowpad.ai

flowpad-0.2.91/flow_sdk/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.91"

{flowpad-0.2.89 → flowpad-0.2.91}/flow_sdk/app/actions/oauth_action.py

@@ -10,17 +10,17 @@ Routes:
 
 import logging
 
-from flow_sdk.core import action
-from flow_sdk.api.oauth_api import OAuthAction, OAuthErrorCode, OAuthProvider, OauthClientRequestInfo
+from flow_sdk.api.oauth_api import OAuthAction, OauthClientRequestInfo, OAuthProvider
 from flow_sdk.app.actions.desktop_oauth import (
     _desktop_oauth_sessions,
     cancel_github_device_flow,
     delete_anthropic_token_for_current_user,
-    get_desktop_oauth_auth_url,
     get_anthropic_token_for_current_user,
+    get_desktop_oauth_auth_url,
     handle_desktop_oauth_callback,
     wait_for_desktop_oauth_callback,
 )
+from flow_sdk.core import action
 from flow_sdk.request_context.methods import get_current_request_info
 from flow_sdk.responses.response import ApiFailResponse, ApiResponse, ApiSuccessResponse
 
@@ -237,30 +237,22 @@ async def _handle_auth(provider: str, request_info) -> ApiResponse:
 
     # Extract user_id from request context
     user_id = ""
-    if request_info and hasattr(request_info, 'target_entity_id') and request_info.target_entity_id:
+    if request_info and hasattr(request_info, "target_entity_id") and request_info.target_entity_id:
         user_id = request_info.target_entity_id
-    elif request_info and hasattr(request_info, 'user') and request_info.user:
-        user_id = request_info.user.id if hasattr(request_info.user, 'id') else str(request_info.user)
+    elif request_info and hasattr(request_info, "user") and request_info.user:
+        user_id = request_info.user.id if hasattr(request_info.user, "id") else str(request_info.user)
 
     return await get_desktop_oauth_auth_url(provider, user_id)
 
 
 async def _get_flowpad_cloud_oauth_auth() -> ApiResponse:
     """Generate Flowpad cloud login URL."""
-    from flow_sdk.cli.auth.cloud_urls import get_login_url
-    from flow_sdk.instance_settings import get_instance_settings
-
-    settings = get_instance_settings()
-    callback_path = "/auth/login_callback"
-    if settings.docker_public_url:
-        callback_url = f"{settings.docker_public_url}{callback_path}"
-    else:
-        callback_url = f"http://127.0.0.1:{settings.port}{callback_path}"
+    from flow_sdk.cli.auth.cloud_urls import desktop_login_callback_url, get_login_url
 
     return ApiSuccessResponse(
         data=OauthClientRequestInfo(
             provider=OAuthProvider.FLOWPAD_CLOUD,
-            auth_url=get_login_url(callback_url),
+            auth_url=get_login_url(desktop_login_callback_url()),
             # Fixed ID — must match the oauth_request_id broadcast by _finalize_login
             oauth_request_id=OAuthProvider.FLOWPAD_CLOUD,
         )

{flowpad-0.2.89 → flowpad-0.2.91}/flow_sdk/builtin/shell.py

@@ -14,12 +14,12 @@ import asyncio
 import logging
 import os
 from datetime import datetime, timezone
-from flow_sdk._compat import StrEnum
-from typing import TYPE_CHECKING, ClassVar
+from typing import TYPE_CHECKING
 
 import psutil
 
-from flow_sdk.api.api_types.api_field import APIField, Persist
+from flow_sdk._compat import StrEnum
+from flow_sdk.api.api_types.api_field import APIField
 from flow_sdk.core import action
 from flow_sdk.core.entity.entity_model import Entity
 from flow_sdk.db.drivers.db_base_record import BuiltinEntityType
@@ -29,7 +29,11 @@ from flow_sdk.responses.response import ApiFailResponse, ApiResponse, ApiSuccess
 from flow_sdk.utils.serialization import now_epoch_ms
 
 if TYPE_CHECKING:
-    from flow_sdk.builtin.agentic_process.cli_drivers.cli_worker_base_driver import WorkerCLIOptions, WorkerExecutionInfo
+    from flow_sdk.api.api_types.type_id import TypeId
+    from flow_sdk.builtin.agentic_process.cli_drivers.cli_worker_base_driver import (
+        WorkerCLIOptions,
+        WorkerExecutionInfo,
+    )
     from flow_sdk.builtin.faas.compute_node import ComputeNode
     from flow_sdk.builtin.faas.pty_session import Pty
 
@@ -51,7 +55,6 @@ def get_shell_record(uid: str) -> FSRecord | None:
 
 def shell_pty_stream_path(record_id: str, pty_pid: str | None):
     """Path to the .pty stream file for a shell session."""
-    from pathlib import Path
     from flow_sdk.fs_store.fs_record import record_stem
     from flow_sdk.fs_store.record_paths import get_default_records_data_root
 
@@ -79,6 +82,7 @@ def close_shell_record(record: FSRecord) -> None:
             pass
     record.save_metadata_field("status", ShellStatus.CLOSED.value)
 
+
 class Shell(Entity):
     """Entity representing a shell tab (PTY session).
 
@@ -121,7 +125,9 @@ class Shell(Entity):
             "Cleared the first time the user manually renames this tab in the UI."
         ),
     )
-    last_launch_cmd: dict | None = APIField(default=None, description="Serialized WorkerCLIOptions from the last launch() call")
+    last_launch_cmd: dict | None = APIField(
+        default=None, description="Serialized WorkerCLIOptions from the last launch() call"
+    )
 
     def get_implicit_private_context_entities(self) -> list["TypeId"]:
         """Project the owning process into private context (the reverse of
@@ -161,6 +167,7 @@ class Shell(Entity):
         if self._bound_compute_node is not None:
             return self._bound_compute_node
         from flow_sdk.builtin.faas.compute_node import ComputeNode
+
         return ComputeNode(
             id=self.compute_node_id or "",
             node_provider_id="local",
@@ -285,7 +292,9 @@ class Shell(Entity):
                 return False
 
         if expected_session_id:
-            actual_session_id = cls._argv_flag_value(cmdline, "--session-id") or cls._argv_flag_value(cmdline, "--resume")
+            actual_session_id = cls._argv_flag_value(cmdline, "--session-id") or cls._argv_flag_value(
+                cmdline, "--resume"
+            )
             # Only fail when cmdline carries an explicit session id that
             # disagrees with ours. Workers whose interactive mode doesn't
             # surface session_id on argv (codex TUI) leave actual=None;
@@ -311,7 +320,9 @@ class Shell(Entity):
         except (psutil.NoSuchProcess, psutil.AccessDenied):
             return False
 
-        expected_session_id = self._argv_flag_value(spawn_args, "--session-id") or self._argv_flag_value(spawn_args, "--resume")
+        expected_session_id = self._argv_flag_value(spawn_args, "--session-id") or self._argv_flag_value(
+            spawn_args, "--resume"
+        )
         return self._cmdline_matches_expected(
             cmdline,
             expected_exe=spawn_args[0],
@@ -355,6 +366,7 @@ class Shell(Entity):
         if not self.project_id:
             try:
                 from flow_sdk.builtin.project import Project  # noqa: PLC0415
+
                 local = await Project.get_by_prop("uname", "local", "project")
                 if local is not None and getattr(local, "id", None):
                     self.project_id = local.id
@@ -418,6 +430,10 @@ class Shell(Entity):
 
         if existing and not existing.is_alive:
             await existing.kill()
+            # A dead PTY handle does not imply a dead worker — sweep the
+            # session before respawning so the fresh ``--resume`` can't
+            # collide with a surviving worker's JSONL session lock.
+            await self.terminate_worker()
         elif existing:
             if connection_id:
                 await existing.attach(connection_id)
@@ -468,31 +484,65 @@ class Shell(Entity):
         await self.stop()
         await self.start_pty()
 
+    def _session_worker_procs(self, session_id: str, exclude: set[int]) -> list[psutil.Process]:
+        """Every live process whose argv names *session_id* via --session-id/--resume.
+
+        The session id is a UUID unique to this shell's worker session, so an
+        argv match is a positive identification regardless of which pid the
+        shell row currently records.
+        """
+        matches: list[psutil.Process] = []
+        for proc in psutil.process_iter(["pid", "cmdline"]):
+            if proc.info["pid"] in exclude:
+                continue
+            cmdline = proc.info.get("cmdline") or []
+            sid = self._argv_flag_value(cmdline, "--session-id") or self._argv_flag_value(cmdline, "--resume")
+            if sid == session_id:
+                matches.append(proc)
+        return matches
+
     async def terminate_worker(self) -> None:
-        """Gracefully kill the Claude worker and wait for full reap.
+        """Gracefully kill EVERY worker on this shell's session and wait for full reap.
+
+        Victims are the recorded ``worker_pid`` (+ descendants) PLUS a sweep of
+        all live processes whose argv carries this session's id — a relaunch
+        overwrites ``worker_pid`` (see ``start_pty``), so a still-live previous
+        worker can be orphaned with no pid record; its held JSONL session lock
+        would make every subsequent ``claude --resume`` collide and stall.
 
-        SIGTERM the worker and its descendants, wait up to 3s for the kernel
+        SIGTERM the victims and their descendants, wait up to 3s for the kernel
         to reap them, then SIGKILL any survivors and wait again. Returns only
         once every victim is fully reaped — once that holds, any flock-held
         resources (e.g. Claude's JSONL session lock) are released, so a
-        subsequent ``claude --resume`` won't collide with the dead worker's
+        subsequent ``claude --resume`` won't collide with a dead worker's
         leftover lock file.
 
         Shell entity and PTY are left alive (status unchanged).
-        Uses self.worker_pid set by _launch_worker_process().
         """
-        pid = self.worker_pid
-        if not pid:
-            return
-        try:
-            proc = psutil.Process(pid)
-        except (psutil.NoSuchProcess, psutil.AccessDenied):
+        victims: list[psutil.Process] = []
+        if self.worker_pid:
+            try:
+                proc = psutil.Process(self.worker_pid)
+                try:
+                    victims = [proc, *proc.children(recursive=True)]
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    victims = [proc]
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                pass
+
+        launch_cmd = getattr(self, "last_launch_cmd", None)
+        session_id = launch_cmd.get("session_id") if isinstance(launch_cmd, dict) else None
+        if session_id:
+            seen = {p.pid for p in victims}
+            for proc in self._session_worker_procs(session_id, seen):
+                victims.append(proc)
+                try:
+                    victims.extend(c for c in proc.children(recursive=True) if c.pid not in seen)
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    pass
+
+        if not victims:
             return
-        try:
-            children = proc.children(recursive=True)
-        except (psutil.NoSuchProcess, psutil.AccessDenied):
-            children = []
-        victims = [proc, *children]
 
         for p in victims:
             try:
@@ -605,9 +655,11 @@ class Shell(Entity):
         """Stream live PTY output as it arrives. Delegates to self.pty.output()."""
         pty_handle = self.compute_node.get_pty(self.id)
         if pty_handle is None:
+
             async def _empty():
                 return
                 yield
+
             return _empty()
         return pty_handle.output()
 
@@ -720,9 +772,7 @@ class Shell(Entity):
 
         return True
 
-    async def _poll_for_worker_pid(
-        self, shell_pid: int | None, executable: str, timeout: float = 1.0
-    ) -> int | None:
+    async def _poll_for_worker_pid(self, shell_pid: int | None, executable: str, timeout: float = 1.0) -> int | None:
         """Poll for a child process of shell_pid whose argv[0] matches executable."""
         import os as _os
 
@@ -740,8 +790,7 @@ class Shell(Entity):
                         # whose argv[0] is the runtime (e.g. ``node``) and
                         # argv[1] is the script path (e.g. ``codex``).
                         if cmdline and any(
-                            _os.path.splitext(_os.path.basename(c))[0].casefold() == expected
-                            for c in cmdline[:2]
+                            _os.path.splitext(_os.path.basename(c))[0].casefold() == expected for c in cmdline[:2]
                         ):
                             return child.pid
                     except (psutil.NoSuchProcess, psutil.AccessDenied):

{flowpad-0.2.89 → flowpad-0.2.91}/flow_sdk/cli/auth/cloud_login.py

@@ -23,8 +23,8 @@ import httpx
 from flow_sdk.api.messages import OAuthMessage, OAuthMessageStatus
 from flow_sdk.api.oauth_api import OAuthProvider
 from flow_sdk.cli.app_config import set_user
+from flow_sdk.cli.auth.cloud_urls import desktop_login_callback_url, get_login_url
 from flow_sdk.cli.auth.credentials import UserHubCredentials, load_credentials, save_credentials
-from flow_sdk.cli.auth.cloud_urls import get_login_url
 from flow_sdk.cloud_client import ApiConfig, FlowpadClient
 from flow_sdk.cloud_client.api.auth import LoginData
 from flow_sdk.instance_settings import get_instance_settings
@@ -65,7 +65,7 @@ async def cloud_login() -> dict[str, Any]:
             # Browser-mode: success/failure arrives later via the OAuth WS
             # callback. LOGGED_IN / LOGIN_FAILED are emitted from there
             # (_finalize_login on success, _broadcast_oauth_error on error).
-            return await _login_by_window(settings.port, settings.cloud_login_timeout_seconds)
+            return await _login_by_window(settings.cloud_login_timeout_seconds)
 
         if kind == "local":
             if not (settings.cloud_user_email and settings.cloud_user_pass):
@@ -87,21 +87,23 @@ async def _login_by_api(email: str, password: str) -> dict[str, Any]:
     return {"status": "logged_in", "user": login_data.user}
 
 
-async def _login_by_window(port: int, timeout: float) -> dict[str, Any]:
+async def _login_by_window(timeout: float) -> dict[str, Any]:
     # Race window: the cloud could redirect-back before this function returns,
     # so reset the waiter state BEFORE opening the browser.
     from flow_sdk.server import state
+
     state.login_received.clear()
     state.login_result = None
     asyncio.create_task(_wait_or_timeout(timeout))
 
-    url = get_login_url(f"http://127.0.0.1:{port}/auth/login_callback")
+    url = get_login_url(desktop_login_callback_url())
     await asyncio.to_thread(webbrowser.open, url)
     return {"status": "started", "url": url}
 
 
 async def _wait_or_timeout(timeout: float) -> None:
     from flow_sdk.server import state
+
     success = await asyncio.to_thread(state.login_received.wait, timeout)
     if not success:
         await _broadcast_oauth_error(f"Login timed out after {int(timeout)}s — please try again")
@@ -123,8 +125,7 @@ async def _post_cloud_login(email: str, password: str) -> LoginData:
         # Transport failure — hub process is down, DNS resolution failed,
         # connection refused, network unreachable, etc.
         raise RuntimeError(
-            "Cloud is not available. The hub server can't be reached — "
-            "check your connection or try again in a moment."
+            "Cloud is not available. The hub server can't be reached — check your connection or try again in a moment."
         ) from e
     except ValueError as e:
         # ``FlowpadClient._unwrap`` raises ValueError for non-200 / non-success
@@ -155,6 +156,7 @@ async def _post_cloud_login(email: str, password: str) -> LoginData:
         # from the embedded response body so the user sees what the hub
         # said rather than a generic fallback.
         import re as _re
+
         m = _re.search(r'"message"\s*:\s*"([^"]+)"', text)
         if m:
             raise RuntimeError(f"Cloud sign-in failed: {m.group(1)}") from e
@@ -186,11 +188,13 @@ async def _finalize_login(login_data: LoginData) -> None:
             user_info["organization_id"] = org_id
             user_info["organization_role"] = login_data.organization_role or "member"
 
-    await _broadcast_oauth(OAuthMessage(
-        oauth_request_id=OAuthProvider.FLOWPAD_CLOUD,
-        status=OAuthMessageStatus.SUCCESS,
-        user=user_info,
-    ))
+    await _broadcast_oauth(
+        OAuthMessage(
+            oauth_request_id=OAuthProvider.FLOWPAD_CLOUD,
+            status=OAuthMessageStatus.SUCCESS,
+            user=user_info,
+        )
+    )
 
     # Defensive: ensure consent marker exists before save_credentials writes
     # to instance.sod (which raises SecretsNotEnabledError without consent).
@@ -198,15 +202,14 @@ async def _finalize_login(login_data: LoginData) -> None:
     # explanation page → enable_secrets approval; this call is a no-op on
     # that path but covers any non-canonical caller that reaches here.
     from flow_sdk.cli.auth.secrets import enable_secrets
+
     enable_secrets()
     save_credentials(UserHubCredentials.from_login_data(login_data))
     # Read-back verification: confirms the sod write decrypts cleanly. Pass the
     # just-logged-in user id explicitly — the config.json active-user pointer
     # (set_user below) isn't committed yet, so a zero-arg load here would
     # resolve the PREVIOUS active user's scoped entries, not this login's.
-    login_user_id = (
-        str(user_info["id"]) if isinstance(user_info, dict) and user_info.get("id") else None
-    )
+    login_user_id = str(user_info["id"]) if isinstance(user_info, dict) and user_info.get("id") else None
     stored = load_credentials(login_user_id)
     stored_ok = stored is not None and stored.api_key == login_data.token
     sodot_path = get_instance_settings().sodot_path
@@ -233,6 +236,7 @@ async def _finalize_login(login_data: LoginData) -> None:
     # immediately. ``set_login_status`` is the single funnel for login state.
     from flow_sdk.cloud_client.auth_state import set_login_status
     from flow_sdk.cloud_client.auth_status import HubLoginStatus
+
     await set_login_status(HubLoginStatus.LOGGED_IN, user=user_info)
 
     try:
@@ -246,21 +250,25 @@ async def _finalize_login(login_data: LoginData) -> None:
 async def _broadcast_oauth(msg: OAuthMessage) -> None:
     try:
         from flow_sdk.server.routes.websocket import broadcast
+
         await broadcast(msg.model_dump_json())
     except Exception:
         pass
 
 
 async def _broadcast_oauth_error(message: str) -> None:
-    await _broadcast_oauth(OAuthMessage(
-        oauth_request_id=OAuthProvider.FLOWPAD_CLOUD,
-        status=OAuthMessageStatus.ERROR,
-        message=message,
-    ))
+    await _broadcast_oauth(
+        OAuthMessage(
+            oauth_request_id=OAuthProvider.FLOWPAD_CLOUD,
+            status=OAuthMessageStatus.ERROR,
+            message=message,
+        )
+    )
     # Mirror the failure into the canonical login-status channel so UI code
     # that has migrated to the new event no longer has to listen to OAuth.
     from flow_sdk.cloud_client.auth_state import set_login_status
     from flow_sdk.cloud_client.auth_status import HubLoginStatus
+
     await set_login_status(HubLoginStatus.LOGIN_FAILED, reason=message)
 
 

flowpad-0.2.91/flow_sdk/cli/auth/cloud_urls.py

@@ -0,0 +1,42 @@
+"""URL builders for the cloud login / logout redirect flows.
+
+These compose ``ApiConfig`` templates with a local-callback URL and live
+in the auth package because they're auth-specific. ``cloud_login.py``,
+``server/routes/cloud.py``, and ``app/actions/oauth_action.py`` are the only
+callers.
+"""
+
+from urllib.parse import quote
+
+from flow_sdk.cloud_client import ApiConfig
+
+
+def get_login_url(redirect_url: str) -> str:
+    """Build the cloud login URL with ``redirect_url`` URL-encoded into the template."""
+    template = ApiConfig.from_env().get_full_login_url()
+    return template.replace("{redirect_url}", quote(redirect_url, safe=""))
+
+
+def desktop_login_callback_url() -> str:
+    """The local ``/auth/login_callback`` URL the cloud redirects back to,
+    carrying this instance's identity as the ``instance`` query param.
+
+    The hub uses that param to name the desktop API key
+    (``desktop-cli:<instance id>``), so key rotation on login is scoped to
+    THIS machine+instance and can never revoke another machine's session.
+    The single construction site for the desktop callback URL — both the CLI
+    browser-window flow and the UI OAuth flow must build it here so the
+    param is never dropped.
+    """
+    from flow_sdk.instance_settings import get_instance_settings  # noqa: PLC0415
+    from flow_sdk.utils.machine_id import desktop_instance_id  # noqa: PLC0415
+
+    settings = get_instance_settings()
+    base = settings.docker_public_url or f"http://127.0.0.1:{settings.port}"
+    return f"{base}/auth/login_callback?instance={desktop_instance_id()}"
+
+
+def get_logout_url(return_url: str) -> str:
+    """Build the cloud logout URL with ``return_url`` URL-encoded into the template."""
+    template = ApiConfig.from_env().get_full_logout_url()
+    return template.replace("{return_url}", quote(return_url, safe=""))

{flowpad-0.2.89 → flowpad-0.2.91}/flow_sdk/compute/providers/desktop/provider.py

@@ -152,41 +152,6 @@ else:
     termios = None
 
 
-def _winpty_safe_cwd(path: str) -> str:
-    """Return a winpty-safe working directory on Windows.
-
-    winpty rejects directory paths whose characters aren't representable in the
-    system ANSI code page, surfacing as ``[WinError 123]`` (ERROR_INVALID_NAME)
-    — e.g. a project folder with Hebrew characters on a Latin Windows install.
-    The 8.3 "short" name of an *existing* directory is pure ASCII, so resolve to
-    it when available. Falls back to the original path when short-name
-    generation is disabled on the volume (``GetShortPathNameW`` then echoes the
-    input) or anything goes wrong, so we never regress the ASCII-path case.
-
-    The directory must already exist for the short name to resolve — callers
-    must ``os.makedirs`` first.
-    """
-    if sys.platform != PLATFORM_WIN32:
-        return path
-    try:
-        import ctypes
-        from ctypes import wintypes
-
-        GetShortPathNameW = ctypes.windll.kernel32.GetShortPathNameW  # type: ignore[attr-defined]
-        GetShortPathNameW.argtypes = [wintypes.LPCWSTR, wintypes.LPWSTR, wintypes.DWORD]
-        GetShortPathNameW.restype = wintypes.DWORD
-
-        needed = GetShortPathNameW(path, None, 0)
-        if needed == 0:
-            return path
-        buf = ctypes.create_unicode_buffer(needed)
-        if GetShortPathNameW(path, buf, needed) == 0:
-            return path
-        return buf.value or path
-    except Exception:
-        return path
-
-
 def _ps_single_quote(value: str) -> str:
     """Quote a string as a PowerShell single-quoted literal.
 
@@ -839,19 +804,23 @@ class LocalComputeProvider(ComputeProvider):
                         f"non-UTF-8 decode)."
                     ) from mkdir_exc
 
-                # winpty can't represent non-ASCII (e.g. Hebrew) cwd paths and
-                # fails with [WinError 123]; spawn against the ASCII 8.3 short
-                # name on Windows. No-op elsewhere and for already-ASCII paths.
-                spawn_cwd = _winpty_safe_cwd(pty_working_dir)
-
+                # Spawn with the cwd EXACTLY as given — never rewrite it.
+                # Session-keyed CLIs (claude/codex/copilot) derive their
+                # transcript-store key from the exact cwd string, so any
+                # rewrite (e.g. the 8.3 short name a since-removed workaround
+                # substituted here) makes ``--resume`` look up the wrong key
+                # and exit immediately — the "Flowpad workspace" crash-loop.
+                # Non-ASCII (e.g. Hebrew) cwds are fine as-is: pywinpty ≥ 3
+                # spawns them correctly on both the ConPTY and winpty backends
+                # (covered by a real-PTY test in test_desktop_path_unicode.py).
                 logger.info(
-                    f"Spawning PTY (session={session_id}, cwd={spawn_cwd!r}, "
+                    f"Spawning PTY (session={session_id}, cwd={pty_working_dir!r}, "
                     f"argv={final_spawn_args!r})"
                 )
                 try:
                     return PtyProcess.spawn(  # type: ignore[union-attr]
                         final_spawn_args,
-                        cwd=spawn_cwd,
+                        cwd=pty_working_dir,
                         env=env,
                         dimensions=(rows, cols),
                     )
@@ -863,16 +832,13 @@ class LocalComputeProvider(ComputeProvider):
                     # every spawn input so the NEXT failure is self-diagnosing.
                     logger.error(
                         "PTY spawn failed (session=%s): %r\n"
-                        "  argv      = %r\n"
-                        "  cwd(raw)  = %r\n"
-                        "  cwd(spawn)= %r  (short_path_applied=%s)\n"
-                        "  PATH      = %r",
+                        "  argv = %r\n"
+                        "  cwd  = %r\n"
+                        "  PATH = %r",
                         session_id,
                         spawn_exc,
                         final_spawn_args,
                         pty_working_dir,
-                        spawn_cwd,
-                        spawn_cwd != pty_working_dir,
                         env.get("PATH"),
                         exc_info=True,
                     )

{flowpad-0.2.89 → flowpad-0.2.91}/flow_sdk/server/routes/auth.py

@@ -54,7 +54,9 @@ async def login_callback(
         )
 
         if not flowpad_api_key:
-            raise ValueError("No API key provided. Expected 'flowpad-api-key' parameter.")
+            raise ValueError(
+                "No API key provided. Expected 'flowpad-api-key' parameter. Restart Flowpad and upgrade your version."
+            )
 
         # Pre-flight the OS-keychain approval ONLY under signed Electron
         # (FLOWPAD_DESKTOP=1, set by electron/uv-manager.js::start()). Only
@@ -71,12 +73,14 @@ async def login_callback(
             return RedirectResponse(url=f"/electron/keychain-approval?{qs}", status_code=302)
 
         user_info = await validate_api_key_async(flowpad_api_key)
-        await _finalize_login(LoginData(
-            token=flowpad_api_key,
-            expires=None,
-            refresh_token=None,
-            user=user_info,
-        ))
+        await _finalize_login(
+            LoginData(
+                token=flowpad_api_key,
+                expires=None,
+                refresh_token=None,
+                user=user_info,
+            )
+        )
 
         if next and next.startswith("/"):
             return RedirectResponse(url=next, status_code=302)