codicent-cli 0.8.2__tar.gz → 0.8.4__tar.gz

{codicent_cli-0.8.2 → codicent_cli-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codicent-cli
-Version: 0.8.2
+Version: 0.8.4
 Summary: Command-line interface for the Codicent API
 Home-page: https://github.com/izaxon/codicent-cli
 Author: Johan Isaksson

{codicent_cli-0.8.2 → codicent_cli-0.8.4}/app.py

@@ -132,10 +132,28 @@ EXAMPLES:
     codicent init --template koi-studio
     codicent wrap claude
     codicent terminal
+    codicent daemon
     codicent update
     codicent update --install
     echo "Help me debug this" | codicent
 
+DAEMON (Remote AI Outpost):
+    daemon              Run as a long-lived background agent that polls for and
+                        executes delegated commands from the AI (execute_command,
+                        fs_read, fs_write, fs_list, fs_search). Use this to turn a
+                        CLI instance into a persistent remote outpost for maintenance.
+    
+    The daemon watches the Codicent project for function_result messages containing
+    delegation markers and executes them on behalf of the AI. Session identity ensures
+    only commands posted by THIS daemon instance are picked up when multiple daemons
+    run against the same project.
+
+    Config (~/.codicent/wrap-config.yaml):
+        autopilot_level: 0   # 0=always confirm, 1=confirm risky, 2=fully autonomous
+        allowed_paths:       # Restrict fs_* tool access (empty = all paths allowed)
+          - /var/log
+          - /home/user/project
+
 UPDATE:
     update              Check if a newer version is available on PyPI
         --install       Also upgrade immediately via pip
@@ -147,7 +165,7 @@ For more information, visit: https://github.com/izaxon/codicent-cli
 """
     print(help_text.strip())
 
-CURRENT_VERSION = "0.8.1"
+CURRENT_VERSION = "0.8.4"
 
 def show_version():
     """Display version information."""
@@ -163,6 +181,312 @@ def validate_input(question):
     
     return True, None
 
+
+# ---------------------------------------------------------------------------
+# CLI config (shares ~/.codicent/wrap-config.yaml with the wrap command)
+# ---------------------------------------------------------------------------
+CLI_CONFIG_PATH = os.path.join(os.path.expanduser("~"), ".codicent", "wrap-config.yaml")
+
+def load_cli_config():
+    """Load CLI config from ~/.codicent/wrap-config.yaml."""
+    config = {"autopilot_level": 0, "allowed_paths": []}
+    if os.path.exists(CLI_CONFIG_PATH):
+        try:
+            import yaml
+            with open(CLI_CONFIG_PATH, "r") as f:
+                user_config = yaml.safe_load(f) or {}
+            config.update(user_config)
+        except Exception as e:
+            logger.warning(f"Could not load CLI config: {e}")
+    return config
+
+
+# ---------------------------------------------------------------------------
+# Delegation helpers
+# ---------------------------------------------------------------------------
+DELEGATION_PREFIXES = (
+    "#execute_command\n",
+    "#fs_read\n",
+    "#fs_write\n",
+    "#fs_list\n",
+    "#fs_search\n",
+)
+
+
+def _check_allowed_path(path, allowed_paths):
+    """Return True if path is within any of the allowed_paths (or if list is empty)."""
+    if not allowed_paths:
+        return True
+    import pathlib
+    try:
+        target = pathlib.Path(path).resolve()
+    except Exception:
+        return False
+    for allowed in allowed_paths:
+        try:
+            allowed_abs = pathlib.Path(allowed).resolve()
+            target.relative_to(allowed_abs)
+            return True
+        except ValueError:
+            continue
+    return False
+
+
+def _parse_delegation(function_result_content):
+    """
+    Parse a raw #function_result message content and return
+    (function_name, delegation_prefix, data_dict, tool_id) if it is a delegation,
+    or None otherwise.
+
+    function_result_content: the full message content string from GetMessageHistory,
+    e.g. '@project\\n#function_result\\n{"role":"function","name":"execute_command","content":"#execute_command\\n{...}","id":"..."}' 
+    """
+    # Strip @mention and leading tags
+    body = re.sub(r"^@\S+\s*", "", function_result_content).strip()
+    body = re.sub(r"^#function_result\s*\n?", "", body).strip()
+    try:
+        fr = json.loads(body)
+    except Exception:
+        return None
+    fc = fr.get("content", "")
+    for prefix in DELEGATION_PREFIXES:
+        if fc.startswith(prefix):
+            try:
+                data = json.loads(fc[len(prefix):])
+            except Exception:
+                return None
+            return fr.get("name", ""), prefix.rstrip("\n").lstrip("#"), data, fr.get("id", "")
+    return None
+
+
+def _execute_fs_delegation(function_name, data, allowed_paths):
+    """Execute a filesystem delegation and return a result string."""
+    import pathlib
+    import fnmatch
+
+    if function_name == "fs_read":
+        path = data.get("path", "")
+        if not _check_allowed_path(path, allowed_paths):
+            return f"Error: path '{path}' is not within allowed_paths"
+        try:
+            with open(path, "r", encoding="utf-8", errors="replace") as f:
+                content = f.read()
+            return content
+        except Exception as e:
+            return f"Error reading file: {e}"
+
+    elif function_name == "fs_write":
+        path = data.get("path", "")
+        content = data.get("content", "")
+        if not _check_allowed_path(path, allowed_paths):
+            return f"Error: path '{path}' is not within allowed_paths"
+        try:
+            os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True)
+            with open(path, "w", encoding="utf-8") as f:
+                f.write(content)
+            return f"Written {len(content)} characters to '{path}'"
+        except Exception as e:
+            return f"Error writing file: {e}"
+
+    elif function_name == "fs_list":
+        path = data.get("path", "")
+        if not _check_allowed_path(path, allowed_paths):
+            return f"Error: path '{path}' is not within allowed_paths"
+        try:
+            entries = os.listdir(path)
+            lines = []
+            for entry in sorted(entries):
+                full = os.path.join(path, entry)
+                suffix = "/" if os.path.isdir(full) else ""
+                lines.append(entry + suffix)
+            return "\n".join(lines) if lines else "(empty)"
+        except Exception as e:
+            return f"Error listing directory: {e}"
+
+    elif function_name == "fs_search":
+        base = data.get("path", "")
+        pattern = data.get("pattern", "*")
+        query = data.get("query")
+        if not _check_allowed_path(base, allowed_paths):
+            return f"Error: path '{base}' is not within allowed_paths"
+        try:
+            matched = []
+            for root, dirs, files in os.walk(base):
+                # Prune hidden dirs
+                dirs[:] = [d for d in dirs if not d.startswith(".")]
+                for fname in files:
+                    if fnmatch.fnmatch(fname, pattern):
+                        fpath = os.path.join(root, fname)
+                        if query:
+                            try:
+                                with open(fpath, "r", encoding="utf-8", errors="replace") as f:
+                                    if query.lower() in f.read().lower():
+                                        matched.append(fpath)
+                            except Exception:
+                                pass
+                        else:
+                            matched.append(fpath)
+            return "\n".join(matched[:500]) if matched else "(no matches)"
+        except Exception as e:
+            return f"Error searching: {e}"
+
+    return f"Error: unknown fs function '{function_name}'"
+
+
+def _execute_shell_delegation(data, allowed_paths, autopilot_level, console, interactive, require_confirm_fn=None):
+    """
+    Execute a shell command delegation.
+    Returns (output_str, success_bool).
+    require_confirm_fn: callable(cmd) -> bool, called when autopilot_level < 2.
+    If None, always executes (daemon mode trusts autopilot_level).
+    """
+    cmd = data.get("command", "")
+    working_dir = data.get("working_directory")
+    timeout = data.get("timeout_seconds", 30)
+
+    if not cmd:
+        return "Error: empty command", False
+
+    # Autopilot gate
+    if require_confirm_fn is not None and autopilot_level < 2:
+        if not require_confirm_fn(cmd):
+            return "Command skipped by user.", False
+
+    try:
+        result = subprocess.run(
+            cmd,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            cwd=working_dir,
+            encoding="utf-8",
+            errors="replace",
+        )
+        parts = []
+        if result.stdout:
+            parts.append(result.stdout.strip())
+        if result.stderr:
+            parts.append(f"stderr: {result.stderr.strip()}")
+        parts.append(f"exit_code: {result.returncode}")
+        return "\n".join(parts), result.returncode == 0
+    except subprocess.TimeoutExpired:
+        return f"Error: command timed out after {timeout}s", False
+    except Exception as e:
+        return f"Error: {e}", False
+
+
+def _post_function_result_msg(base_url, token, verify_https, project, parent_id, function_name, result_content, tool_id):
+    """Post a #function_result message as a child of parent_id (the delegation message)."""
+    fr = {"role": "function", "name": function_name, "content": result_content, "id": tool_id or ""}
+    body = f"@{project}\n#function_result\n{json.dumps(fr)}"
+    url = f"{base_url}app/AddChatMessage"
+    payload = {"content": body, "type": "ai-chat-answer2", "parentId": str(parent_id)}
+    try:
+        resp = requests.post(
+            url,
+            json=payload,
+            headers={"Authorization": f"Bearer {token}"},
+            verify=verify_https,
+            timeout=30,
+        )
+        resp.raise_for_status()
+        return resp.json()
+    except Exception as e:
+        logger.error(f"Failed to post function result: {e}")
+        return None
+
+
+def _start_chat_async(base_url, token, verify_https, project, message, conversation_id=None):
+    """Post chat message via StartAi2ChatAsync and return the promptMessageId."""
+    payload = {"message": message, "project": project}
+    if conversation_id:
+        payload["messageId"] = str(conversation_id)
+    url = f"{base_url}app/StartAi2ChatAsync"
+    resp = requests.post(
+        url,
+        json=payload,
+        headers={"Authorization": f"Bearer {token}"},
+        verify=verify_https,
+        timeout=30,
+    )
+    resp.raise_for_status()
+    return resp.json().get("promptMessageId")
+
+
+def _fetch_history(base_url, token, verify_https, message_id):
+    """Fetch conversation history chain for the given message_id."""
+    url = f"{base_url}app/GetMessageHistory"
+    resp = requests.get(
+        url,
+        params={"messageId": str(message_id)},
+        headers={"Authorization": f"Bearer {token}"},
+        verify=verify_https,
+        timeout=15,
+    )
+    resp.raise_for_status()
+    return resp.json() if resp.text else []
+
+
+def _wait_for_ai_reply_with_delegation(
+    base_url, token, verify_https, project, prompt_message_id,
+    on_delegation, poll_interval=1.5, timeout=360
+):
+    """
+    Poll GetMessageHistory until a final text reply is found.
+    Calls on_delegation(msg_content, msg_id) when a delegation is detected.
+    Returns {id, content} of the final text message, or None on timeout.
+    """
+    import time
+    deadline = time.time() + timeout
+    last_seen_id = None
+
+    while time.time() < deadline:
+        try:
+            history = _fetch_history(base_url, token, verify_https, prompt_message_id)
+        except Exception as e:
+            logger.warning(f"History fetch error: {e}")
+            time.sleep(poll_interval)
+            continue
+
+        if not history or len(history) < 2:
+            time.sleep(poll_interval)
+            continue
+
+        # Latest message in the chain (leaf)
+        last = history[-1]
+        last_id = last.get("id") or last.get("Id")
+        content = last.get("content") or last.get("Content", "")
+
+        if last_id == last_seen_id:
+            time.sleep(poll_interval)
+            continue
+        last_seen_id = last_id
+
+        # Check for delegation in function_result messages
+        if "#function_result" in content:
+            delegation = _parse_delegation(content)
+            if delegation:
+                on_delegation(content, last_id)
+                time.sleep(poll_interval)
+                continue
+
+        # Check if this is an intermediate (non-finished) engine state
+        intermediate_markers = [
+            "#chat2", "#finish_reason_function_call", "#finish_reason_tool_calls_batch",
+            "#function_result", "#function_results_batch",
+        ]
+        if any(m in content for m in intermediate_markers):
+            time.sleep(poll_interval)
+            continue
+
+        # Finished: strip @mention and leading tags for display
+        clean = re.sub(r"^@\S+\s*", "", content).strip()
+        clean = re.sub(r"^(#\S+\s*)+", "", clean).strip()
+        return {"id": last_id, "content": clean}
+
+    return None  # timeout
+
 def main():
     console = Console()
     
@@ -542,6 +866,124 @@ def main():
         return 0 if failed == 0 else 1
 
     # Handle wrap command
+    # -----------------------------------------------------------------------
+    # daemon subcommand — persistent remote AI outpost
+    # -----------------------------------------------------------------------
+    if len(sys.argv) > 1 and sys.argv[1] == "daemon":
+        import time
+        import uuid
+
+        daemon_token = auth.get_cached_token()
+        if not daemon_token:
+            daemon_token = os.getenv("CODICENT_TOKEN")
+        if not daemon_token:
+            console.print("[red]❌ No authentication found.[/red]")
+            console.print("[dim]Run 'codicent auth' to authenticate, or set CODICENT_TOKEN[/dim]")
+            return 1
+
+        try:
+            dp = daemon_token.split(".")[1]
+            dp += '=' * (-len(dp) % 4)
+            daemon_jwt = json.loads(base64.urlsafe_b64decode(dp).decode('utf-8'))
+            daemon_project = daemon_jwt["project"]
+            daemon_base_url = daemon_jwt.get("baseUrl", "https://codicent.com/")
+            daemon_verify = True
+        except Exception as e:
+            console.print(f"[red]❌ Failed to extract project from token: {e}[/red]")
+            return 1
+
+        daemon_config = load_cli_config()
+        daemon_autopilot = daemon_config.get("autopilot_level", 0)
+        daemon_allowed = daemon_config.get("allowed_paths", [])
+        daemon_poll_interval = daemon_config.get("daemon", {}).get("poll_interval", 5)
+
+        # Stable session identity — persistent across restarts when using the same token
+        session_id = daemon_jwt.get("sub", "")[:16] or str(uuid.uuid4())[:8]
+        console.print(f"[bold green]🤖 Codicent Daemon started[/bold green] (session={session_id})")
+        console.print(f"[dim]Project: {daemon_project} | Autopilot level: {daemon_autopilot} | Poll: {daemon_poll_interval}s[/dim]")
+        if daemon_allowed:
+            console.print(f"[dim]Allowed paths: {daemon_allowed}[/dim]")
+
+        # Track delegation messages we have posted results for (avoid double-execution)
+        executed_ids = set()
+
+        # We watch for delegation markers in "pending" messages addressed via session_id
+        # The engine embeds session_id in every delegation JSON if provided in the tool call.
+        # Format: @project #function_result {"role":"function","name":"...","content":"#execute_command\n{...session_id:...}","id":"..."}
+
+        def _fetch_pending_delegations():
+            """Fetch unhandled (leaf) function_result messages for this project."""
+            url = f"{daemon_base_url}app/GetPendingDelegations"
+            try:
+                resp = requests.get(
+                    url,
+                    params={"project": daemon_project, "maxMessages": 50},
+                    headers={"Authorization": f"Bearer {daemon_token}"},
+                    verify=daemon_verify,
+                    timeout=15,
+                )
+                resp.raise_for_status()
+                return resp.json() if resp.text else []
+            except Exception as e:
+                logger.debug(f"Daemon poll error: {e}")
+                return []
+
+        try:
+            while True:
+                msgs = _fetch_pending_delegations()
+                for msg in msgs:
+                    msg_id = msg.get("id") or msg.get("Id")
+                    if not msg_id or msg_id in executed_ids:
+                        continue
+                    content = msg.get("content") or msg.get("Content", "")
+                    if "#function_result" not in content:
+                        continue
+
+                    delegation = _parse_delegation(content)
+                    if not delegation:
+                        continue
+
+                    func_name, op, data, tool_id = delegation
+
+                    # Filter by session_id if present in the delegation data
+                    msg_session = data.get("session_id", "")
+                    if msg_session and msg_session != session_id:
+                        continue
+
+                    # Mark as handled immediately to avoid duplicate execution
+                    executed_ids.add(msg_id)
+
+                    console.print(f"\n[bold cyan]→ Delegation:[/bold cyan] {op} | msg_id={msg_id}")
+
+                    if op == "execute_command":
+                        cmd = data.get("command", "")
+                        console.print(f"  cmd: {cmd}")
+                        if daemon_autopilot < 1:
+                            # Non-interactive: always require autopilot_level >= 1 for daemon
+                            result_str = "Daemon requires autopilot_level >= 1 for execute_command. Set in ~/.codicent/wrap-config.yaml."
+                        else:
+                            result_str, _ = _execute_shell_delegation(
+                                data, daemon_allowed, daemon_autopilot, console, False, None
+                            )
+                    else:
+                        result_str = _execute_fs_delegation(op, data, daemon_allowed)
+
+                    console.print(f"  result: {result_str[:160]}{'…' if len(result_str) > 160 else ''}")
+                    _post_function_result_msg(
+                        daemon_base_url, daemon_token, daemon_verify,
+                        daemon_project, msg_id, func_name, result_str, tool_id
+                    )
+
+                # Trim executed_ids if it gets large
+                if len(executed_ids) > 2000:
+                    executed_ids = set(list(executed_ids)[-1000:])
+
+                time.sleep(daemon_poll_interval)
+
+        except KeyboardInterrupt:
+            console.print("\n[yellow]Daemon stopped.[/yellow]")
+            return 0
+
     if len(sys.argv) > 1 and sys.argv[1] == "wrap":
         from wrap import run_wrap_command
 
@@ -627,6 +1069,9 @@ def main():
         return 1
     
     conversationId = None
+    cli_config = load_cli_config()
+    autopilot_level = cli_config.get("autopilot_level", 0)
+    allowed_paths = cli_config.get("allowed_paths", [])
 
     # Parse interactive mode flags
     interactive = False
@@ -682,30 +1127,92 @@ def main():
                 console.print("[green]✅ Message posted successfully.[/green]")
             else:
                 logger.info("Sending chat reply to Codicent API")
-                with console.status("[dim]🤔 Thinking...[/dim]", spinner="dots"):
-                    response = codicent.post_chat_reply(question, conversationId)
-                conversationId = response["id"]
+
+                # --- Async delegation loop ---
+                def handle_delegation(msg_content, msg_id):
+                    """Called when a delegation message is found during inline wait."""
+                    delegation = _parse_delegation(msg_content)
+                    if not delegation:
+                        return
+                    func_name, op, data, tool_id = delegation
+
+                    if op == "execute_command":
+                        cmd = data.get("command", "")
+                        console.print(f"\n[bold yellow]⚡ AI wants to run:[/bold yellow] {cmd}")
+
+                        def confirm_fn(c):
+                            if autopilot_level >= 2:
+                                return True
+                            if not interactive:
+                                return autopilot_level >= 1
+                            try:
+                                ans = prompt("Allow? (y/N) ")
+                                return ans.strip().lower() == "y"
+                            except (KeyboardInterrupt, EOFError):
+                                return False
+
+                        with console.status("[dim]Running command...[/dim]", spinner="dots"):
+                            result_str, _ = _execute_shell_delegation(
+                                data, allowed_paths, autopilot_level, console, interactive, confirm_fn
+                            )
+                        console.print(f"[dim]Result: {result_str[:200]}{'…' if len(result_str) > 200 else ''}[/dim]")
+                        _post_function_result_msg(
+                            codicent.base_url, token, codicent.verify_https,
+                            project, msg_id, func_name, result_str, tool_id
+                        )
+
+                    elif op in ("fs_read", "fs_write", "fs_list", "fs_search"):
+                        path = data.get("path", "")
+                        console.print(f"\n[bold yellow]📂 AI filesystem op:[/bold yellow] {op} {path}")
+                        if not _check_allowed_path(path, allowed_paths):
+                            result_str = f"Error: path '{path}' is not within allowed_paths"
+                        else:
+                            with console.status("[dim]Executing...[/dim]", spinner="dots"):
+                                result_str = _execute_fs_delegation(op, data, allowed_paths)
+                        console.print(f"[dim]{result_str[:200]}{'…' if len(result_str) > 200 else ''}[/dim]")
+                        _post_function_result_msg(
+                            codicent.base_url, token, codicent.verify_https,
+                            project, msg_id, func_name, result_str, tool_id
+                        )
+
+                try:
+                    prompt_id = _start_chat_async(
+                        codicent.base_url, token, codicent.verify_https,
+                        project, question, conversationId
+                    )
+                except Exception:
+                    # Fallback to synchronous post_chat_reply (no delegation support)
+                    with console.status("[dim]🤔 Thinking...[/dim]", spinner="dots"):
+                        response = codicent.post_chat_reply(question, conversationId)
+                    conversationId = response["id"]
+                    content = response["content"]
+                else:
+                    with console.status("[dim]🤔 Thinking...[/dim]", spinner="dots"):
+                        response = _wait_for_ai_reply_with_delegation(
+                            codicent.base_url, token, codicent.verify_https,
+                            project, prompt_id, handle_delegation
+                        )
+                    if response is None:
+                        console.print("[red]⏱ Request timed out or no reply received.[/red]")
+                        return False
+                    conversationId = response["id"]
+                    content = response["content"]
+
                 logger.info(f"Updated conversation ID: {conversationId}")
-                
+
                 # Show bot response with markdown formatting in green
                 if interactive:
                     console.print()
-                
-                content = response["content"]
-                
-                # Detect shell: markers in AI response
+
+                # Backward-compat: detect legacy shell: markers in AI response
                 shell_commands = re.findall(r'^shell:(.+)$', content, re.MULTILINE)
-                
-                # Also detect ```shell code blocks
                 shell_blocks = re.findall(r'```shell\n(.*?)```', content, re.DOTALL)
-                
-                # Create markdown with green styling
+
                 from rich.text import Text
                 markdown_content = Markdown(content)
                 console.print(markdown_content, style="green")
                 console.print()
-                
-                # Offer to run detected shell commands
+
                 all_commands = shell_commands + [block.strip() for block in shell_blocks]
                 for cmd in all_commands:
                     cmd = cmd.strip()
@@ -720,7 +1227,6 @@ def main():
                         if confirm.strip().lower() == 'y':
                             console.print(f"[dim]Running: {cmd}[/dim]")
                             try:
-                                # Run command with proper encoding handling for cross-platform compatibility
                                 result = subprocess.run(
                                     cmd,
                                     shell=True,
@@ -728,10 +1234,9 @@ def main():
                                     text=True,
                                     timeout=60,
                                     encoding='utf-8',
-                                    errors='replace'  # Replace invalid chars instead of failing
+                                    errors='replace'
                                 )
 
-                                # Display output to user
                                 if result.stdout:
                                     console.print(result.stdout)
                                 if result.stderr:
@@ -741,57 +1246,37 @@ def main():
                                 else:
                                     console.print(f"[red]Exit code: {result.returncode}[/red]")
 
-                                # Send command output back to AI chat so it can see the results
-                                output_parts = []
-                                output_parts.append(f"Command executed: `{cmd}`")
-                                output_parts.append("")
+                                output_parts = [f"Command executed: `{cmd}`", ""]
                                 if result.stdout:
-                                    output_parts.append("Output:")
-                                    output_parts.append("```")
-                                    output_parts.append(result.stdout.strip())
-                                    output_parts.append("```")
+                                    output_parts += ["Output:", "```", result.stdout.strip(), "```"]
                                 if result.stderr:
-                                    output_parts.append("Errors:")
-                                    output_parts.append("```")
-                                    output_parts.append(result.stderr.strip())
-                                    output_parts.append("```")
+                                    output_parts += ["Errors:", "```", result.stderr.strip(), "```"]
                                 output_parts.append(f"Exit code: {result.returncode}")
-
                                 command_output = "\n".join(output_parts)
 
-                                # Post the output back to the chat
-                                with console.status("[dim]Sending output to AI...[/dim]", spinner="dots"):
-                                    response = codicent.post_chat_reply(command_output, conversationId)
-                                conversationId = response["id"]
-
-                                # Show AI's response to the command output
-                                console.print()
-                                console.print("[dim]AI response:[/dim]")
-                                ai_response = response["content"]
-                                markdown_content = Markdown(ai_response)
-                                console.print(markdown_content, style="green")
-                                console.print()
+                                try:
+                                    prompt_id2 = _start_chat_async(
+                                        codicent.base_url, token, codicent.verify_https,
+                                        project, command_output, conversationId
+                                    )
+                                    with console.status("[dim]Sending output to AI...[/dim]", spinner="dots"):
+                                        resp2 = _wait_for_ai_reply_with_delegation(
+                                            codicent.base_url, token, codicent.verify_https,
+                                            project, prompt_id2, handle_delegation
+                                        )
+                                    if resp2:
+                                        conversationId = resp2["id"]
+                                        console.print()
+                                        console.print("[dim]AI response:[/dim]")
+                                        console.print(Markdown(resp2["content"]), style="green")
+                                        console.print()
+                                except Exception as e:
+                                    logger.warning(f"Could not send shell output back to AI: {e}")
 
                             except subprocess.TimeoutExpired:
-                                error_msg = "Command timed out after 60 seconds"
-                                console.print(f"[red]{error_msg}[/red]")
-                                # Send timeout info to AI
-                                try:
-                                    with console.status("[dim]Sending timeout info to AI...[/dim]", spinner="dots"):
-                                        response = codicent.post_chat_reply(f"Command timed out: `{cmd}`", conversationId)
-                                    conversationId = response["id"]
-                                except Exception:
-                                    pass  # Don't fail if we can't send the timeout
+                                console.print("[red]Command timed out after 60 seconds[/red]")
                             except Exception as e:
-                                error_msg = f"Error: {e}"
-                                console.print(f"[red]{error_msg}[/red]")
-                                # Send error info to AI
-                                try:
-                                    with console.status("[dim]Sending error info to AI...[/dim]", spinner="dots"):
-                                        response = codicent.post_chat_reply(f"Command failed: `{cmd}`\nError: {str(e)}", conversationId)
-                                    conversationId = response["id"]
-                                except Exception:
-                                    pass  # Don't fail if we can't send the error
+                                console.print(f"[red]Error: {e}[/red]")
                         else:
                             console.print("[dim]Skipped.[/dim]")
                     else:

{codicent_cli-0.8.2 → codicent_cli-0.8.4}/codicent_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codicent-cli
-Version: 0.8.2
+Version: 0.8.4
 Summary: Command-line interface for the Codicent API
 Home-page: https://github.com/izaxon/codicent-cli
 Author: Johan Isaksson

{codicent_cli-0.8.2 → codicent_cli-0.8.4}/setup.py

@@ -9,7 +9,7 @@ except FileNotFoundError:
 
 setup(
     name='codicent-cli',
-    version='0.8.2',
+    version='0.8.4',
     author='Johan Isaksson',
     author_email='johan@izaxon.com',
     description='Command-line interface for the Codicent API',

{codicent_cli-0.8.2 → codicent_cli-0.8.4}/terminal.py

@@ -70,7 +70,8 @@ def run_terminal_host(token: str, base_url: str, project: str, shell: str = None
     )
 
     print(f"[codicent terminal] project=@{project}  shell={shell}  session={session_id}")
-    print(f"[codicent terminal] Connecting to {base_url} ...")
+    ws_display = f"{ws_base}/terminal/host?project={project}&command={os.path.basename(shell)}&sessionId={session_id}"
+    print(f"[codicent terminal] Connecting to {ws_display} ...")
 
     stop_event = threading.Event()
     ws_app = None
@@ -101,7 +102,9 @@ def run_terminal_host(token: str, base_url: str, project: str, shell: str = None
         _set_pty_size(cols, rows)
 
         def on_open(ws):
-            print("[codicent terminal] Connected. Shell is ready in the browser.")
+            browser_url = f"{base_url.rstrip('/')}/terminal/ws?sessionId={session_id}"
+            print(f"[codicent terminal] Connected. Shell is ready in the browser.")
+            print(f"[codicent terminal] Browser connect: {browser_url}")
             # Send initial resize
             import json
             ws.send(json.dumps({"type": "resize", "cols": cols, "rows": rows}))
@@ -199,7 +202,9 @@ def run_terminal_host(token: str, base_url: str, project: str, shell: str = None
         threading.Thread(target=_stdout_reader, daemon=True).start()
 
         def on_open(ws):
-            print("[codicent terminal] Connected.")
+            browser_url = f"{base_url.rstrip('/')}/terminal/ws?sessionId={session_id}"
+            print(f"[codicent terminal] Connected.")
+            print(f"[codicent terminal] Browser connect: {browser_url}")
 
             # Thread: drain queue -> WebSocket
             def _sender():