From de2befe31e73f88a4f86d3d0e2241e5aae510bad Mon Sep 17 00:00:00 2001 From: Loki Date: Mon, 29 Jun 2026 21:09:27 +0000 Subject: [PATCH] Phase 7 : outils web_search et run_shell avec validation MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Backend : - tools.py : web_search (DuckDuckGo HTML sans clé, ou SearxNG via SEARX_URL) et run_shell (confiné au workspace, sortie bornée, timeout) - agent.py : run_shell sensible -> émet tool_confirm et ne s'exécute pas tant que l'utilisateur n'a pas validé (confirm_shell) - agent_config.py : web_search/run_shell désactivés par défaut, flag confirm_shell - routes/shell.py : POST /api/shell/run exécute une commande validée - routes/chat.py : relaie l'événement tool_confirm, passe confirm_shell Frontend : - streamChat : événement tool_confirm - store : pendingShell + approveShell/rejectShell (réinjecte le résultat à l'agent) - ChatPanel : carte de validation de commande (Approuver / Refuser) - SettingsView : toggles web_search/run_shell, marqueur sensible, switch confirm_shell - ToolCard : glyphes web_search/run_shell, statut 'à valider', aperçu d'argument Tests : run_shell confiné, gate de confirmation (commande dangereuse non exécutée), route shell, parser DuckDuckGo. Co-Authored-By: Claude Opus 4.8 Claude-Session: https://claude.ai/code/session_01SVay7z3y7q2gEe54ByAE6N --- README.md | 8 +- backend/app/agent.py | 48 ++++++++- backend/app/agent_config.py | 25 ++++- backend/app/main.py | 3 +- backend/app/routes/chat.py | 11 +-- backend/app/routes/shell.py | 33 +++++++ backend/app/tools.py | 139 +++++++++++++++++++++++++++ frontend/src/api/client.ts | 16 ++- frontend/src/components/ToolCard.tsx | 27 +++++- frontend/src/panels/ChatPanel.tsx | 50 ++++++++++ frontend/src/panels/SettingsView.tsx | 31 +++++- frontend/src/store/useStore.ts | 33 +++++++ 12 files changed, 398 insertions(+), 26 deletions(-) create mode 100644 backend/app/routes/shell.py diff --git a/README.md b/README.md index 767bfdf..7093093 100644 --- a/README.md +++ b/README.md @@ -72,10 +72,10 @@ npm run dev # http://localhost:5173 - [x] **Phase 2** — Connexion Ollama : statut, liste des modèles, pull avec progression, sélecteur - [x] **Phase 3** — Chat streaming (SSE) + persistance des sessions (SQLite) - [x] **Phase 4** — Boucle agentique & outils fichiers (read/write/list), confinés au workspace, rendu des appels d'outils dans le fil -- [~] **Phase 5** — Aperçu HTML live + onglet Code + arborescence du workspace (fait) · onglet Logs (à venir) -- [ ] **Phase 6** — Configuration complète (génération, toggles d'outils, invite système) -- [ ] **Phase 7** — Outils avancés (web_search, run_shell confirmé, html_preview) -- [ ] **Phase 8** — Hardening & documentation Docker +- [x] **Phase 5** — Aperçu HTML live + onglets Code/Logs + arborescence du workspace +- [x] **Phase 6** — Configuration complète (génération, toggles d'outils, invite système) +- [x] **Phase 7** — Outils avancés : `web_search` (DuckDuckGo/SearxNG) et `run_shell` avec validation utilisateur +- [x] **Phase 8** — Durcissement & documentation Docker ## Structure diff --git a/backend/app/agent.py b/backend/app/agent.py index 3360f98..93981d4 100644 --- a/backend/app/agent.py +++ b/backend/app/agent.py @@ -41,6 +41,7 @@ async def run_agent( *, options: dict | None = None, enabled_tools: list[str] | None = None, + confirm_shell: bool = True, ) -> AsyncIterator[dict]: # enabled_tools=None -> tous les outils ; liste vide -> aucun outil. if enabled_tools is None: @@ -83,6 +84,7 @@ async def run_agent( break # Exécution des outils demandés, puis réinjection des résultats. + awaiting_confirmation = False for tc in tool_calls: fn = tc.get("function", {}) name = fn.get("name", "") @@ -90,10 +92,39 @@ async def run_agent( yield {"type": "tool_call", "name": name, "args": args} + # run_shell est sensible : on demande validation au lieu d'exécuter. + if name == "run_shell" and confirm_shell: + command = args.get("command", "") + record = { + "name": name, + "args": args, + "summary": "validation requise", + "status": "pending", + } + collected.append(record) + yield {"type": "tool_confirm", "name": name, "command": command} + convo.append( + { + "role": "tool", + "name": name, + "content": json.dumps( + { + "ok": False, + "status": "pending", + "message": "Commande en attente de validation " + "de l'utilisateur. N'exécute rien d'autre.", + }, + ensure_ascii=False, + ), + } + ) + awaiting_confirmation = True + continue + try: result = run_tool(name, args) summary = result.get("summary", "terminé") - status = "ok" + status = result.get("_status", "ok") except ToolError as exc: result = {"ok": False, "error": str(exc)} summary = str(exc) @@ -110,6 +141,21 @@ async def run_agent( "content": json.dumps(result, ensure_ascii=False), } ) + + # Une commande shell attend une validation : on interrompt la boucle. + if awaiting_confirmation: + # Laisse le modèle conclure son tour (message d'attente). + final_chunk = "" + async for chunk in ollama.chat(model, convo, options=options, stream=True): + tok = chunk.get("message", {}).get("content", "") + if tok: + final_chunk += tok + yield {"type": "token", "content": tok} + if chunk.get("done"): + break + if final_chunk.strip(): + text_parts.append(final_chunk.strip()) + break except (httpx.HTTPError, OSError) as exc: yield {"type": "error", "message": str(exc)} return diff --git a/backend/app/agent_config.py b/backend/app/agent_config.py index 286f653..32e8313 100644 --- a/backend/app/agent_config.py +++ b/backend/app/agent_config.py @@ -16,8 +16,17 @@ DEFAULT_SYSTEM_PROMPT = ( "concise en français. Après avoir écrit un fichier, propose un aperçu." ) -# Outils réellement disponibles (les sensibles arrivent en phase 7). -AVAILABLE_TOOLS = ["read_file", "write_file", "list_dir"] +# Outils disponibles. Les sensibles (web_search, run_shell) sont désactivés +# par défaut, conformément à la maquette. +AVAILABLE_TOOLS = ["read_file", "write_file", "list_dir", "web_search", "run_shell"] +SENSITIVE_TOOLS = {"run_shell"} +DEFAULT_TOOL_STATE = { + "read_file": True, + "write_file": True, + "list_dir": True, + "web_search": False, + "run_shell": False, +} DEFAULT_CONFIG: dict = { "system_prompt": DEFAULT_SYSTEM_PROMPT, @@ -25,7 +34,9 @@ DEFAULT_CONFIG: dict = { "top_p": 0.9, "top_k": 40, "max_tokens": 2048, - "tools": {name: True for name in AVAILABLE_TOOLS}, + "tools": dict(DEFAULT_TOOL_STATE), + # Demander une validation utilisateur avant toute commande shell. + "confirm_shell": True, } @@ -34,7 +45,7 @@ def get_config() -> dict: stored = db.get_config_value(CONFIG_KEY) or {} cfg = {**DEFAULT_CONFIG, **stored} cfg["tools"] = { - name: bool(stored.get("tools", {}).get(name, True)) + name: bool(stored.get("tools", {}).get(name, DEFAULT_TOOL_STATE[name])) for name in AVAILABLE_TOOLS } return cfg @@ -45,7 +56,11 @@ def save_config(patch: dict) -> dict: cfg = {**get_config(), **{k: v for k, v in patch.items() if v is not None}} if "tools" in patch and patch["tools"]: cfg["tools"] = { - name: bool(patch["tools"].get(name, cfg["tools"].get(name, True))) + name: bool( + patch["tools"].get( + name, cfg["tools"].get(name, DEFAULT_TOOL_STATE[name]) + ) + ) for name in AVAILABLE_TOOLS } db.set_config_value(CONFIG_KEY, cfg) diff --git a/backend/app/main.py b/backend/app/main.py index 033cf40..010d803 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -14,7 +14,7 @@ from fastapi.staticfiles import StaticFiles from . import db from .config import settings -from .routes import chat, config, files, models, sessions +from .routes import chat, config, files, models, sessions, shell @asynccontextmanager @@ -41,6 +41,7 @@ app.include_router(sessions.router) app.include_router(chat.router) app.include_router(files.router) app.include_router(config.router) +app.include_router(shell.router) @app.get("/api/health") diff --git a/backend/app/routes/chat.py b/backend/app/routes/chat.py index 71b618b..cbc9ae5 100644 --- a/backend/app/routes/chat.py +++ b/backend/app/routes/chat.py @@ -60,16 +60,11 @@ async def chat(req: ChatRequest) -> StreamingResponse: convo, options=agent_config.ollama_options(cfg), enabled_tools=agent_config.enabled_tool_names(cfg), + confirm_shell=cfg.get("confirm_shell", True), ): etype = ev.pop("type") - if etype == "token": - yield _sse("token", ev) - elif etype == "tool_call": - yield _sse("tool_call", ev) - elif etype == "tool_result": - yield _sse("tool_result", ev) - elif etype == "error": - yield _sse("error", ev) + if etype in ("token", "tool_call", "tool_result", "tool_confirm", "error"): + yield _sse(etype, ev) elif etype == "final": final_content = ev["content"] tools_meta = ev["tools"] diff --git a/backend/app/routes/shell.py b/backend/app/routes/shell.py new file mode 100644 index 0000000..8aeb902 --- /dev/null +++ b/backend/app/routes/shell.py @@ -0,0 +1,33 @@ +"""Route d'exécution d'une commande shell validée par l'utilisateur. + +La boucle agentique n'exécute jamais run_shell elle-même quand la confirmation +est active : elle émet un événement `tool_confirm`. Le client affiche la +commande, et c'est seulement après clic explicite de l'utilisateur que cette +route exécute la commande (confinée au workspace). +""" +from __future__ import annotations + +from fastapi import APIRouter, HTTPException +from pydantic import BaseModel + +from ..tools import ToolError, run_shell + +router = APIRouter(prefix="/api/shell", tags=["shell"]) + + +class ShellRequest(BaseModel): + command: str + + +@router.post("/run") +async def run(req: ShellRequest) -> dict: + """Exécute la commande validée et renvoie sa sortie.""" + try: + result = run_shell(req.command) + except ToolError as exc: + raise HTTPException(400, str(exc)) + return { + "command": req.command, + "exit_code": result["exit_code"], + "output": result["output"], + } diff --git a/backend/app/tools.py b/backend/app/tools.py index aa42a54..794af5b 100644 --- a/backend/app/tools.py +++ b/backend/app/tools.py @@ -9,7 +9,12 @@ toute tentative de sortie (../, chemin absolu hors workspace) est rejetée. """ from __future__ import annotations +import html import os +import re +import subprocess + +import httpx from .config import settings @@ -71,11 +76,114 @@ def list_dir(path: str = ".") -> dict: } +def web_search(query: str, max_results: int = 5) -> dict: + """Recherche web (DuckDuckGo HTML, sans clé d'API). + + Optionnellement, si SEARX_URL est défini, interroge une instance SearxNG. + Renvoie une liste de résultats {title, url, snippet}. + """ + query = (query or "").strip() + if not query: + raise ToolError("requête de recherche vide") + + searx = os.environ.get("SEARX_URL") + try: + if searx: + results = _search_searx(searx, query, max_results) + else: + results = _search_duckduckgo(query, max_results) + except httpx.HTTPError as exc: + raise ToolError(f"recherche web indisponible : {exc}") from exc + + summary = f"{len(results)} résultat(s)" if results else "aucun résultat" + return {"ok": True, "results": results, "summary": summary} + + +def _search_searx(base: str, query: str, n: int) -> list[dict]: + with httpx.Client(timeout=10.0) as client: + r = client.get( + base.rstrip("/") + "/search", + params={"q": query, "format": "json"}, + ) + r.raise_for_status() + data = r.json().get("results", [])[:n] + return [ + {"title": d.get("title", ""), "url": d.get("url", ""), + "snippet": d.get("content", "")} + for d in data + ] + + +_DDG_RESULT = re.compile( + r']*class="result__a"[^>]*href="([^"]+)"[^>]*>(.*?)' + r'.*?class="result__snippet"[^>]*>(.*?)', + re.DOTALL, +) +_TAGS = re.compile(r"<[^>]+>") + + +def _clean(text: str) -> str: + return html.unescape(_TAGS.sub("", text)).strip() + + +def _search_duckduckgo(query: str, n: int) -> list[dict]: + with httpx.Client(timeout=10.0, follow_redirects=True) as client: + r = client.post( + "https://html.duckduckgo.com/html/", + data={"q": query}, + headers={"User-Agent": "Mozilla/5.0 (Loki agent)"}, + ) + r.raise_for_status() + results = [] + for url, title, snippet in _DDG_RESULT.findall(r.text)[:n]: + results.append({ + "title": _clean(title), + "url": html.unescape(url), + "snippet": _clean(snippet), + }) + return results + + +def run_shell(command: str, timeout: int = 60) -> dict: + """Exécute une commande shell dans le workspace (outil sensible). + + L'exécution effective n'a lieu qu'après validation utilisateur (gérée par + la boucle agentique / la route /api/shell). Confinée au workspace. + """ + command = (command or "").strip() + if not command: + raise ToolError("commande vide") + try: + proc = subprocess.run( + command, + shell=True, + cwd=_workspace_root(), + capture_output=True, + text=True, + timeout=timeout, + ) + except subprocess.TimeoutExpired as exc: + raise ToolError(f"délai dépassé ({timeout}s)") from exc + + out = (proc.stdout or "") + (proc.stderr or "") + out = out[:4000] # borne la taille renvoyée au modèle + status = "ok" if proc.returncode == 0 else "error" + return { + "ok": proc.returncode == 0, + "exit_code": proc.returncode, + "output": out, + "summary": f"code {proc.returncode}", + "_status": status, + } + + # ── Registre & définitions exposées au modèle ──────────────────────────── TOOL_IMPL = { "read_file": read_file, "write_file": write_file, "list_dir": list_dir, + "web_search": web_search, + "run_shell": run_shell, } TOOL_DEFINITIONS = [ @@ -121,6 +229,37 @@ TOOL_DEFINITIONS = [ }, }, }, + { + "type": "function", + "function": { + "name": "web_search", + "description": "Rechercher sur le web et renvoyer les meilleurs résultats.", + "parameters": { + "type": "object", + "properties": { + "query": {"type": "string", "description": "Termes de recherche"} + }, + "required": ["query"], + }, + }, + }, + { + "type": "function", + "function": { + "name": "run_shell", + "description": ( + "Exécuter une commande shell dans le workspace. Outil sensible :" + " l'utilisateur doit valider la commande avant exécution." + ), + "parameters": { + "type": "object", + "properties": { + "command": {"type": "string", "description": "Commande à exécuter"} + }, + "required": ["command"], + }, + }, + }, ] diff --git a/frontend/src/api/client.ts b/frontend/src/api/client.ts index 49e429c..1f2c09f 100644 --- a/frontend/src/api/client.ts +++ b/frontend/src/api/client.ts @@ -42,7 +42,7 @@ export interface ToolCall { name: string; args: Record; summary?: string; - status?: "ok" | "error" | "running"; + status?: "ok" | "error" | "running" | "pending"; } export interface Message { @@ -62,6 +62,18 @@ export interface AgentConfig { top_k: number; max_tokens: number; tools: Record; + confirm_shell: boolean; +} + +export async function runShell( + command: string +): Promise<{ command: string; exit_code: number; output: string }> { + const res = await fetch("/api/shell/run", { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ command }), + }); + return res.json(); } export async function getConfig(): Promise<{ @@ -134,6 +146,7 @@ export async function streamChat( onToken: (t: string) => void; onToolCall: (call: ToolCall) => void; onToolResult: (call: ToolCall) => void; + onToolConfirm: (command: string) => void; onDone: (full: string) => void; onError: (msg: string) => void; } @@ -173,6 +186,7 @@ export async function streamChat( else if (event === "tool_call") handlers.onToolCall({ ...payload, status: "running" }); else if (event === "tool_result") handlers.onToolResult(payload); + else if (event === "tool_confirm") handlers.onToolConfirm(payload.command); else if (event === "done") handlers.onDone(payload.content); else if (event === "error") handlers.onError(payload.message); } catch { diff --git a/frontend/src/components/ToolCard.tsx b/frontend/src/components/ToolCard.tsx index a1562ba..de0f77f 100644 --- a/frontend/src/components/ToolCard.tsx +++ b/frontend/src/components/ToolCard.tsx @@ -4,11 +4,16 @@ import type { ToolCall } from "../api/client"; export function ToolCard({ call }: { call: ToolCall }) { const running = call.status === "running"; const error = call.status === "error"; + const pending = call.status === "pending"; - // Argument principal affiché entre parenthèses (path le plus souvent). + // Argument principal affiché entre parenthèses selon l'outil. + const mainArg = + (call.args?.path as string) ?? + (call.args?.query as string) ?? + (call.args?.command as string); const argPreview = - typeof call.args?.path === "string" - ? `("${call.args.path}")` + typeof mainArg === "string" + ? `("${mainArg.length > 48 ? mainArg.slice(0, 48) + "…" : mainArg}")` : Object.keys(call.args ?? {}).length ? "(…)" : "()"; @@ -32,6 +37,8 @@ export function ToolCard({ call }: { call: ToolCall }) { en cours + ) : pending ? ( + ⏸ à valider ) : ( ); + if (name === "web_search") + return ( + + + + + ); + if (name === "run_shell") + return ( + + + + + ); // read_file (défaut) return ( diff --git a/frontend/src/panels/ChatPanel.tsx b/frontend/src/panels/ChatPanel.tsx index 9dfa5f8..d48e8cb 100644 --- a/frontend/src/panels/ChatPanel.tsx +++ b/frontend/src/panels/ChatPanel.tsx @@ -15,6 +15,9 @@ export function ChatPanel() { sendMessage, currentSessionId, config, + pendingShell, + approveShell, + rejectShell, } = useStore(); const activeTools = config @@ -100,6 +103,13 @@ export function ChatPanel() { pending /> )} + {pendingShell && ( + + )} )} @@ -201,6 +211,46 @@ function Bubble({ msg, pending }: { msg: Message; pending?: boolean }) { ); } +function ShellConfirm({ + command, + onApprove, + onReject, +}: { + command: string; + onApprove: () => void; + onReject: () => void; +}) { + return ( +
+
+ + run_shell + + · commande sensible à valider +
+
+ 
+          $ {command}
+
+
+ + +
+
+
+ ); +} + function Chip({ children }: { children: React.ReactNode }) { return (
diff --git a/frontend/src/panels/SettingsView.tsx b/frontend/src/panels/SettingsView.tsx index f09b3fe..074fd38 100644 --- a/frontend/src/panels/SettingsView.tsx +++ b/frontend/src/panels/SettingsView.tsx @@ -8,7 +8,10 @@ const TOOL_DESC: Record = { read_file: "Lire un fichier du projet", write_file: "Créer / modifier un fichier", list_dir: "Lister un répertoire", + web_search: "Recherche web", + run_shell: "Exécuter une commande", }; +const SENSITIVE = new Set(["run_shell"]); /** Vue Configuration (Frame 2) — Modèle & génération, outils, invite système. */ export function SettingsView() { @@ -279,6 +282,9 @@ export function SettingsView() { {TOOL_DESC[name] ?? ""} + {SENSITIVE.has(name) && ( + · sensible + )}
); })} -
- web_search · run_shell — arrivent bientôt (sensibles) -
+ {draft.tools.run_shell && ( +
+ + Demander une validation avant chaque commande shell + + +
+ )} diff --git a/frontend/src/store/useStore.ts b/frontend/src/store/useStore.ts index 45ce7e4..e7f229b 100644 --- a/frontend/src/store/useStore.ts +++ b/frontend/src/store/useStore.ts @@ -9,6 +9,7 @@ import { fileContent, listFiles, listSessions, + runShell, saveConfig, streamChat, type AgentConfig, @@ -42,6 +43,10 @@ interface LokiState { refreshConfig: () => Promise; updateConfig: (patch: Partial) => Promise; + pendingShell: string | null; // commande shell en attente de validation + approveShell: () => Promise; + rejectShell: () => Promise; + openPreview: (path: string) => Promise; setSelectedModel: (name: string) => void; refreshStatus: () => Promise; @@ -72,6 +77,32 @@ export const useStore = create((set, get) => ({ previewContent: "", config: null, availableTools: [], + pendingShell: null, + + approveShell: async () => { + const cmd = get().pendingShell; + if (!cmd) return; + set({ pendingShell: null }); + let report: string; + try { + const r = await runShell(cmd); + report = + `J'ai validé la commande \`${cmd}\` (code ${r.exit_code}).\n` + + `Sortie :\n\`\`\`\n${r.output || "(vide)"}\n\`\`\``; + } catch { + report = `Échec de l'exécution de \`${cmd}\`.`; + } + await get().refreshFiles(); + // On renvoie le résultat à l'agent pour qu'il poursuive. + await get().sendMessage(report); + }, + + rejectShell: async () => { + const cmd = get().pendingShell; + if (!cmd) return; + set({ pendingShell: null }); + await get().sendMessage(`J'ai refusé la commande \`${cmd}\`. N'exécute pas cette commande.`); + }, refreshConfig: async () => { const { config, available_tools } = await getConfig(); @@ -171,6 +202,7 @@ export const useStore = create((set, get) => ({ streaming: true, streamContent: "", streamTools: [], + pendingShell: null, }); await streamChat( @@ -190,6 +222,7 @@ export const useStore = create((set, get) => ({ } set({ streamTools: tools }); }, + onToolConfirm: (command) => set({ pendingShell: command }), onDone: async () => { // Repère un fichier HTML écrit pour l'afficher automatiquement. const writtenHtml = [...get().streamTools]