klaude-code 1.2.26__py3-none-any.whl → 1.2.28__py3-none-any.whl

klaude_code/cli/config_cmd.py

@@ -16,8 +16,6 @@ def list_models() -> None:
     from klaude_code.ui.terminal.color import is_light_terminal_background
 
     config = load_config()
-    if config is None:
-        raise typer.Exit(1)
 
     # Auto-detect theme when not explicitly set in config, to match other CLI entrypoints.
     if config.theme is None:
@@ -60,9 +58,7 @@ def edit_config() -> None:
             editor = "xdg-open"
 
     # Ensure config file exists
-    config = load_config()
-    if config is None:
-        raise typer.Exit(1)
+    load_config()
 
     try:
         if editor == "open -a TextEdit":

klaude_code/cli/debug.py

@@ -63,7 +63,15 @@ def open_log_file_in_editor(path: Path) -> None:
             editor = "xdg-open"
 
     try:
-        subprocess.Popen([editor, str(path)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        # Detach stdin to prevent the editor from interfering with terminal input state.
+        # Without this, the spawned process inherits the parent's TTY and can disrupt
+        # prompt_toolkit's keyboard handling (e.g., history navigation with up/down keys).
+        subprocess.Popen(
+            [editor, str(path)],
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
     except FileNotFoundError:
         log((f"Error: Editor '{editor}' not found", "red"))
     except Exception as exc:  # pragma: no cover - best effort

klaude_code/cli/list_model.py

@@ -6,44 +6,47 @@ from rich.table import Table
 from rich.text import Text
 
 from klaude_code.config import Config
+from klaude_code.config.config import ModelConfig, ProviderConfig
+from klaude_code.protocol.llm_param import LLMClientProtocol
 from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
 from klaude_code.ui.rich.theme import ThemeKey, get_theme
 
 
-def _display_codex_status(console: Console) -> None:
-    """Display Codex OAuth login status."""
+def _get_codex_status_elements() -> list[Text]:
+    """Get Codex OAuth login status as Text elements for panel display."""
     from klaude_code.auth.codex.token_manager import CodexTokenManager
 
+    elements: list[Text] = []
     token_manager = CodexTokenManager()
     state = token_manager.get_state()
 
     if state is None:
-        console.print(
+        elements.append(
             Text.assemble(
-                ("Codex Status: ", "bold"),
+                ("Status: ", "bold"),
                 ("Not logged in", ThemeKey.CONFIG_STATUS_ERROR),
                 (" (run 'klaude login codex' to authenticate)", "dim"),
             )
         )
     elif state.is_expired():
-        console.print(
+        elements.append(
             Text.assemble(
-                ("Codex Status: ", "bold"),
+                ("Status: ", "bold"),
                 ("Token expired", ThemeKey.CONFIG_STATUS_ERROR),
                 (" (run 'klaude login codex' to re-authenticate)", "dim"),
             )
         )
     else:
         expires_dt = datetime.datetime.fromtimestamp(state.expires_at, tz=datetime.UTC)
-        console.print(
+        elements.append(
             Text.assemble(
-                ("Codex Status: ", "bold"),
+                ("Status: ", "bold"),
                 ("Logged in", ThemeKey.CONFIG_STATUS_OK),
                 (f" (account: {state.account_id[:8]}..., expires: {expires_dt.strftime('%Y-%m-%d %H:%M UTC')})", "dim"),
             )
         )
 
-    console.print(
+    elements.append(
         Text.assemble(
             ("Visit ", "dim"),
             (
@@ -53,6 +56,7 @@ def _display_codex_status(console: Console) -> None:
             (" for up-to-date information on rate limits and credits", "dim"),
         )
     )
+    return elements
 
 
 def mask_api_key(api_key: str | None) -> str:
@@ -66,136 +70,179 @@ def mask_api_key(api_key: str | None) -> str:
     return f"{api_key[:6]} … {api_key[-6:]}"
 
 
-def display_models_and_providers(config: Config):
-    """Display models and providers configuration using rich formatting"""
-    themes = get_theme(config.theme)
-    console = Console(theme=themes.app_theme)
+def format_api_key_display(provider: ProviderConfig) -> Text:
+    """Format API key display with warning if env var is not set."""
+    env_var = provider.get_api_key_env_var()
+    resolved_key = provider.get_resolved_api_key()
 
-    # Display providers section
-    providers_table = Table.grid(padding=(0, 1), expand=True)
-    providers_table.add_column(width=2, no_wrap=True)  # Status
-    providers_table.add_column(overflow="fold")  # Name
-    providers_table.add_column(overflow="fold")  # Protocol
-    providers_table.add_column(overflow="fold")  # Base URL
-    providers_table.add_column(overflow="fold")  # API Key
-
-    # Add header
-    providers_table.add_row(
-        Text("", style="bold"),
-        Text("Name", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("Protocol", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("Base URL", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("API Key", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-    )
+    if env_var:
+        # Using ${ENV_VAR} syntax
+        if resolved_key:
+            return Text.assemble(
+                (f"${{{env_var}}} = ", "dim"),
+                (mask_api_key(resolved_key), ""),
+            )
+        else:
+            return Text.assemble(
+                (f"${{{env_var}}} ", ""),
+                ("(not set)", ThemeKey.CONFIG_STATUS_ERROR),
+            )
+    elif provider.api_key:
+        # Plain API key
+        return Text(mask_api_key(provider.api_key))
+    else:
+        return Text("N/A")
 
-    # Add providers
-    for provider in config.provider_list:
-        status = Text("✔", style=f"bold {ThemeKey.CONFIG_STATUS_OK}")
-        name = Text(provider.provider_name, style=ThemeKey.CONFIG_ITEM_NAME)
-        protocol = Text(str(provider.protocol.value), style="")
-        base_url = Text(provider.base_url or "N/A", style="")
-        api_key = Text(mask_api_key(provider.api_key), style="")
-
-        providers_table.add_row(status, name, protocol, base_url, api_key)
-
-    # Display models section
-    models_table = Table.grid(padding=(0, 1), expand=True)
-    models_table.add_column(width=2, no_wrap=True)  # Status
-    models_table.add_column(overflow="fold", ratio=1)  # Name
-    models_table.add_column(overflow="fold", ratio=2)  # Model
-    models_table.add_column(overflow="fold", ratio=2)  # Provider
-    models_table.add_column(overflow="fold", ratio=3)  # Params
-
-    # Add header
-    models_table.add_row(
-        Text("", style="bold"),
-        Text("Name", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("Model", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("Provider", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("Params", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-    )
 
-    # Add models
-    for model in config.model_list:
-        status = Text("✔", style=f"bold {ThemeKey.CONFIG_STATUS_OK}")
-        if model.model_name == config.main_model:
-            status = Text("★", style=f"bold {ThemeKey.CONFIG_STATUS_PRIMARY}")  # Mark main model
-
-        name = Text(
-            model.model_name,
-            style=ThemeKey.CONFIG_STATUS_PRIMARY
-            if model.model_name == config.main_model
-            else ThemeKey.CONFIG_ITEM_NAME,
-        )
-        model_name = Text(model.model_params.model or "N/A", style="")
-        provider = Text(model.provider, style="")
-        params: list[Text] = []
-        if model.model_params.thinking:
-            if model.model_params.thinking.reasoning_effort is not None:
-                params.append(
-                    Text.assemble(
-                        ("reason-effort", ThemeKey.CONFIG_PARAM_LABEL),
-                        ": ",
-                        model.model_params.thinking.reasoning_effort,
-                    )
-                )
-            if model.model_params.thinking.reasoning_summary is not None:
-                params.append(
-                    Text.assemble(
-                        ("reason-summary", ThemeKey.CONFIG_PARAM_LABEL),
-                        ": ",
-                        model.model_params.thinking.reasoning_summary,
-                    )
+def _get_model_params_display(model: ModelConfig) -> list[Text]:
+    """Get display elements for model parameters."""
+    params: list[Text] = []
+    if model.model_params.thinking:
+        if model.model_params.thinking.reasoning_effort is not None:
+            params.append(
+                Text.assemble(
+                    ("reason-effort", ThemeKey.CONFIG_PARAM_LABEL),
+                    ": ",
+                    model.model_params.thinking.reasoning_effort,
                 )
-            if model.model_params.thinking.budget_tokens is not None:
-                params.append(
-                    Text.assemble(
-                        ("thinking-budget-tokens", ThemeKey.CONFIG_PARAM_LABEL),
-                        ": ",
-                        str(model.model_params.thinking.budget_tokens),
-                    )
+            )
+        if model.model_params.thinking.reasoning_summary is not None:
+            params.append(
+                Text.assemble(
+                    ("reason-summary", ThemeKey.CONFIG_PARAM_LABEL),
+                    ": ",
+                    model.model_params.thinking.reasoning_summary,
                 )
-        if model.model_params.provider_routing:
+            )
+        if model.model_params.thinking.budget_tokens is not None:
             params.append(
                 Text.assemble(
-                    ("provider-routing", ThemeKey.CONFIG_PARAM_LABEL),
+                    ("thinking-budget-tokens", ThemeKey.CONFIG_PARAM_LABEL),
                     ": ",
-                    model.model_params.provider_routing.model_dump_json(exclude_none=True),
+                    str(model.model_params.thinking.budget_tokens),
                 )
             )
-        if len(params) == 0:
-            params.append(Text("N/A", style=ThemeKey.CONFIG_PARAM_LABEL))
-        models_table.add_row(status, name, model_name, provider, Group(*params))
-
-    # Create panels and display
-    providers_panel = Panel(
-        providers_table,
-        title=Text("Providers Configuration", style="white bold"),
-        border_style=ThemeKey.CONFIG_PANEL_BORDER,
-        padding=(0, 1),
-        title_align="left",
-    )
+    if model.model_params.provider_routing:
+        params.append(
+            Text.assemble(
+                ("provider-routing", ThemeKey.CONFIG_PARAM_LABEL),
+                ": ",
+                model.model_params.provider_routing.model_dump_json(exclude_none=True),
+            )
+        )
+    if len(params) == 0:
+        params.append(Text("N/A", style=ThemeKey.CONFIG_PARAM_LABEL))
+    return params
 
-    models_panel = Panel(
-        models_table,
-        title=Text("Models Configuration", style="white bold"),
-        border_style=ThemeKey.CONFIG_PANEL_BORDER,
-        padding=(0, 1),
-        title_align="left",
-    )
 
-    console.print(providers_panel)
-    console.print()
-    console.print(models_panel)
+def display_models_and_providers(config: Config):
+    """Display models and providers configuration using rich formatting"""
+    themes = get_theme(config.theme)
+    console = Console(theme=themes.app_theme)
+
+    # Display each provider as a separate panel
+    for provider in config.provider_list:
+        # Provider info section
+        provider_info = Table.grid(padding=(0, 1))
+        provider_info.add_column(width=12)
+        provider_info.add_column()
+
+        provider_info.add_row(
+            Text("Protocol:", style=ThemeKey.CONFIG_PARAM_LABEL),
+            Text(provider.protocol.value),
+        )
+        if provider.base_url:
+            provider_info.add_row(
+                Text("Base URL:", style=ThemeKey.CONFIG_PARAM_LABEL),
+                Text(provider.base_url or "N/A"),
+            )
+        if provider.api_key:
+            provider_info.add_row(
+                Text("API Key:", style=ThemeKey.CONFIG_PARAM_LABEL),
+                format_api_key_display(provider),
+            )
+
+        # Check if provider has valid API key
+        provider_available = not provider.is_api_key_missing()
+
+        # Models table for this provider
+        models_table = Table.grid(padding=(0, 1), expand=True)
+        models_table.add_column(width=2, no_wrap=True)  # Status
+        models_table.add_column(overflow="fold", ratio=1)  # Name
+        models_table.add_column(overflow="fold", ratio=2)  # Model
+        models_table.add_column(overflow="fold", ratio=3)  # Params
+
+        # Add header
+        models_table.add_row(
+            Text("", style="bold"),
+            Text("Name", style=ThemeKey.CONFIG_TABLE_HEADER),
+            Text("Model", style=ThemeKey.CONFIG_TABLE_HEADER),
+            Text("Params", style=ThemeKey.CONFIG_TABLE_HEADER),
+        )
+
+        # Add models for this provider
+        for model in provider.model_list:
+            if not provider_available:
+                # Provider API key not set - show as unavailable
+                status = Text("-", style="dim")
+                name = Text(model.model_name, style="dim")
+                model_id = Text(model.model_params.model or "N/A", style="dim")
+                params = [Text("(unavailable)", style="dim")]
+            elif model.model_name == config.main_model:
+                status = Text("★", style=ThemeKey.CONFIG_STATUS_PRIMARY)
+                name = Text(model.model_name, style=ThemeKey.CONFIG_STATUS_PRIMARY)
+                model_id = Text(model.model_params.model or "N/A", style="")
+                params = _get_model_params_display(model)
+            else:
+                status = Text("✔", style=ThemeKey.CONFIG_STATUS_OK)
+                name = Text(model.model_name, style=ThemeKey.CONFIG_ITEM_NAME)
+                model_id = Text(model.model_params.model or "N/A", style="")
+                params = _get_model_params_display(model)
+
+            models_table.add_row(status, name, model_id, Group(*params))
+
+        # Create panel content with provider info and models
+        panel_elements = [
+            provider_info,
+            Text(""),  # Spacer
+            Text("Models:", style=ThemeKey.CONFIG_TABLE_HEADER),
+            models_table,
+        ]
+
+        # Add Codex status if this is a codex provider
+        if provider.protocol == LLMClientProtocol.CODEX:
+            panel_elements.append(Text(""))  # Spacer
+            panel_elements.extend(_get_codex_status_elements())
+
+        panel_content = Group(*panel_elements)
+
+        panel = Panel(
+            panel_content,
+            title=Text(f"Provider: {provider.provider_name}", style="white bold"),
+            border_style=ThemeKey.CONFIG_PANEL_BORDER,
+            padding=(0, 1),
+            title_align="left",
+        )
+
+        console.print(panel)
+        console.print()
 
     # Display main model info
     console.print()
-    console.print(
-        Text.assemble(
-            ("Default Model: ", "bold"),
-            (config.main_model, ThemeKey.CONFIG_STATUS_PRIMARY),
+    if config.main_model:
+        console.print(
+            Text.assemble(
+                ("Default Model: ", "bold"),
+                (config.main_model, ThemeKey.CONFIG_STATUS_PRIMARY),
+            )
+        )
+    else:
+        console.print(
+            Text.assemble(
+                ("Default Model: ", "bold"),
+                ("(not set)", ThemeKey.CONFIG_STATUS_ERROR),
+            )
         )
-    )
 
     for profile in iter_sub_agent_profiles():
         sub_model_name = config.sub_agent_models.get(profile.name)
@@ -207,9 +254,3 @@ def display_models_and_providers(config: Config):
                 (sub_model_name, ThemeKey.CONFIG_STATUS_PRIMARY),
             )
         )
-
-    # Display Codex login status if any codex provider is configured
-    has_codex_provider = any(p.protocol.value == "codex" for p in config.provider_list)
-    if has_codex_provider:
-        console.print()
-        _display_codex_status(console)

klaude_code/cli/main.py

@@ -16,6 +16,10 @@ from klaude_code.trace import DebugType, prepare_debug_log_file
 
 def set_terminal_title(title: str) -> None:
     """Set terminal window title using ANSI escape sequence."""
+    # Never write terminal control sequences when stdout is not a TTY (pipes/CI/redirects).
+    # This avoids corrupting machine-readable output (e.g., JSON streaming) and log captures.
+    if not sys.stdout.isatty():
+        return
     sys.stdout.write(f"\033]0;{title}\007")
     sys.stdout.flush()
 
@@ -143,13 +147,28 @@ def exec_command(
         raise typer.Exit(1)
 
     from klaude_code.cli.runtime import AppInitConfig, run_exec
+    from klaude_code.config import load_config
     from klaude_code.config.select_model import select_model_from_config
 
     chosen_model = model
     if model or select_model:
         chosen_model = select_model_from_config(preferred=model)
         if chosen_model is None:
-            return
+            raise typer.Exit(1)
+    else:
+        # Check if main_model is configured; if not, trigger interactive selection
+        config = load_config()
+        if config.main_model is None:
+            chosen_model = select_model_from_config()
+            if chosen_model is None:
+                raise typer.Exit(1)
+            # Save the selection as default
+            config.main_model = chosen_model
+            from klaude_code.config.config import config_path
+            from klaude_code.trace import log
+
+            asyncio.run(config.save())
+            log(f"Saved main_model={chosen_model} to {config_path}", style="cyan")
 
     debug_enabled, debug_filters, log_path = prepare_debug_logging(debug, debug_filter)
 
@@ -227,9 +246,43 @@ def main_callback(
 ) -> None:
     # Only run interactive mode when no subcommand is invoked
     if ctx.invoked_subcommand is None:
+        from klaude_code.trace import log
+
+        resume_by_id_value = resume_by_id.strip() if resume_by_id is not None else None
+        if resume_by_id_value == "":
+            log(("Error: --resume-by-id cannot be empty", "red"))
+            raise typer.Exit(2)
+
+        if resume_by_id_value is not None and (resume or continue_):
+            log(("Error: --resume-by-id cannot be combined with --resume/--continue", "red"))
+            raise typer.Exit(2)
+
+        if resume_by_id_value is not None and not Session.exists(resume_by_id_value):
+            log((f"Error: session id '{resume_by_id_value}' not found for this project", "red"))
+            log(("Hint: run `klaude --resume` to select an existing session", "yellow"))
+            raise typer.Exit(2)
+
+        # In non-interactive environments, default to exec-mode behavior.
+        # This allows: echo "..." | klaude
+        if not sys.stdin.isatty() or not sys.stdout.isatty():
+            if continue_ or resume or resume_by_id is not None:
+                log(("Error: --continue/--resume options require a TTY", "red"))
+                log(("Hint: use `klaude exec` for non-interactive usage", "yellow"))
+                raise typer.Exit(2)
+
+            exec_command(
+                input_content="",
+                model=model,
+                select_model=select_model,
+                debug=debug,
+                debug_filter=debug_filter,
+                vanilla=vanilla,
+                stream_json=False,
+            )
+            return
+
         from klaude_code.cli.runtime import AppInitConfig, run_interactive
         from klaude_code.config.select_model import select_model_from_config
-        from klaude_code.trace import log
 
         update_terminal_title()
 
@@ -243,15 +296,6 @@ def main_callback(
         # session_id=None means create a new session
         session_id: str | None = None
 
-        resume_by_id_value = resume_by_id.strip() if resume_by_id is not None else None
-        if resume_by_id_value == "":
-            log(("Error: --resume-by-id cannot be empty", "red"))
-            raise typer.Exit(2)
-
-        if resume_by_id_value is not None and (resume or continue_):
-            log(("Error: --resume-by-id cannot be combined with --resume/--continue", "red"))
-            raise typer.Exit(2)
-
         if resume:
             session_id = resume_select_session()
             if session_id is None:
@@ -261,10 +305,6 @@ def main_callback(
             session_id = Session.most_recent_session_id()
 
         if resume_by_id_value is not None:
-            if not Session.exists(resume_by_id_value):
-                log((f"Error: session id '{resume_by_id_value}' not found for this project", "red"))
-                log(("Hint: run `klaude --resume` to select an existing session", "yellow"))
-                raise typer.Exit(2)
             session_id = resume_by_id_value
         # If still no session_id, leave as None to create a new session
 
@@ -275,8 +315,8 @@ def main_callback(
             session_meta = Session.load_meta(session_id)
             cfg = load_config()
 
-            if cfg is not None and session_meta.model_config_name:
-                if any(m.model_name == session_meta.model_config_name for m in cfg.model_list):
+            if session_meta.model_config_name:
+                if any(m.model_name == session_meta.model_config_name for m in cfg.iter_model_entries()):
                     chosen_model = session_meta.model_config_name
                 else:
                     log(
@@ -286,17 +326,34 @@ def main_callback(
                         )
                     )
 
-            if cfg is not None and chosen_model is None and session_meta.model_name:
+            if chosen_model is None and session_meta.model_name:
                 raw_model = session_meta.model_name.strip()
                 if raw_model:
                     matches = [
                         m.model_name
-                        for m in cfg.model_list
+                        for m in cfg.iter_model_entries()
                         if (m.model_params.model or "").strip().lower() == raw_model.lower()
                     ]
                     if len(matches) == 1:
                         chosen_model = matches[0]
 
+        # If still no model, check main_model; if not configured, trigger interactive selection
+        if chosen_model is None:
+            from klaude_code.config import load_config
+
+            cfg = load_config()
+            if cfg.main_model is None:
+                chosen_model = select_model_from_config()
+                if chosen_model is None:
+                    raise typer.Exit(1)
+                # Save the selection as default
+                cfg.main_model = chosen_model
+                from klaude_code.config.config import config_path
+                from klaude_code.trace import log
+
+                asyncio.run(cfg.save())
+                log(f"Saved main_model={chosen_model} to {config_path}", style="dim")
+
         debug_enabled, debug_filters, log_path = prepare_debug_logging(debug, debug_filter)
 
         init_config = AppInitConfig(

klaude_code/cli/runtime.py

@@ -62,8 +62,6 @@ async def initialize_app_components(init_config: AppInitConfig) -> AppComponents
     set_debug_logging(init_config.debug, filters=init_config.debug_filters)
 
     config = load_config()
-    if config is None:
-        raise typer.Exit(1)
 
     # Initialize LLM clients
     try:
@@ -160,7 +158,7 @@ async def initialize_session(
 def _backfill_session_model_config(
     agent: Agent | None,
     model_override: str | None,
-    default_model: str,
+    default_model: str | None,
     is_new_session: bool,
 ) -> None:
     """Backfill model_config_name and model_thinking on newly created sessions."""
@@ -169,7 +167,7 @@ def _backfill_session_model_config(
 
     if model_override is not None:
         agent.session.model_config_name = model_override
-    elif is_new_session:
+    elif is_new_session and default_model is not None:
         agent.session.model_config_name = default_model
     else:
         return
@@ -257,12 +255,8 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
 
     # Create status provider for bottom toolbar
     def _status_provider() -> REPLStatusSnapshot:
-        # Check for updates (returns None if uv not available)
         update_message = get_update_message()
-
-        return build_repl_status_snapshot(
-            agent=components.executor.context.current_agent, update_message=update_message
-        )
+        return build_repl_status_snapshot(update_message)
 
     # Set up input provider for interactive mode
     def _stop_rich_bottom_ui() -> None:
@@ -278,9 +272,19 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             display.wrapped_display.renderer.spinner_stop()
             display.wrapped_display.renderer.stop_bottom_live()
 
+    # Pass the pre-detected theme to avoid redundant TTY queries.
+    # Querying the terminal background again after questionary's interactive selection
+    # can interfere with prompt_toolkit's terminal state and break history navigation.
+    is_light_background: bool | None = None
+    if components.theme == "light":
+        is_light_background = True
+    elif components.theme == "dark":
+        is_light_background = False
+
     input_provider: ui.InputProviderABC = ui.PromptToolkitInput(
         status_provider=_status_provider,
         pre_prompt=_stop_rich_bottom_ui,
+        is_light_background=is_light_background,
     )
 
     # --- Custom Ctrl+C handler: double-press within 2s to exit, single press shows toast ---
@@ -305,8 +309,8 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
                 printer.print(Text(f" {MSG} ", style="bold yellow reverse"))
             else:
                 print(MSG, file=sys.stderr)
-        except Exception:
-            # Fallback if themed print is unavailable
+        except (AttributeError, TypeError, RuntimeError):
+            # Fallback if themed print is unavailable (e.g., display not ready or Rich internal error)
             print(MSG, file=sys.stderr)
 
     def _hide_progress() -> None:

klaude_code/cli/self_update.py

@@ -174,7 +174,8 @@ def _print_version() -> None:
         ver = pkg_version(PACKAGE_NAME)
     except PackageNotFoundError:
         ver = "unknown"
-    except Exception:
+    except (ValueError, TypeError):
+        # Catch invalid package name format or type errors
         ver = "unknown"
     print(f"{PACKAGE_NAME} {ver}")
 

klaude_code/cli/session_cmd.py

@@ -13,7 +13,7 @@ def _session_confirm(sessions: list[Session.SessionMetaBrief], message: str) ->
     def _fmt(ts: float) -> str:
         try:
             return time.strftime("%m-%d %H:%M:%S", time.localtime(ts))
-        except Exception:
+        except (OSError, OverflowError, ValueError):
             return str(ts)
 
     log(f"Sessions to delete ({len(sessions)}):")