Name: sdd-kill-server
Author: zekiriabd

Prompt file imported from zekiriabd/SDD-Pro (.codex/prompts/sdd-kill-server.md). Fill in {{arguments}}, {{arg5}}, {{BACK_PORT}}, {{FRONT_PORT}}, {{CONSOLE_PORT}}, {{arg2}}, {{arg1}}, {{PORT}}, {{LABEL}}, {{PID}} before use. Copyright stays with the author.

Arguments: {{arguments}}

/sdd-kill-server — Arrête backend + frontend + console SDD

Utilitaire runtime (depuis v7.0.0) — pendant de /sdd-serve. Stoppe les 3 process tournant en arrière-plan (Spring Boot / Vite / Fastify console) en les identifiant par port. Idempotent. Aucun agent invoqué, aucune mutation du code.

Arrête les 3 process runtime du projet généré :

Backend Java / Spring Boot (port lu depuis application.yml ou défaut stack — 8080 Spring, 5097 .NET, 8000 FastAPI, etc.)
Frontend Node / Vite (port lu depuis vite.config.ts ou défaut 5173)
Console SDD (Node / Fastify, port défaut 4000 ou env PORT)

Usage :

/sdd-kill-server — kill les 3
/sdd-kill-server back — backend seul
/sdd-kill-server front — frontend seul
/sdd-kill-server console — console seule
/sdd-kill-server back front — sous-ensemble
/sdd-kill-server --port 5185 — kill un port arbitraire (utile pour processes orphelins après crash)

Read-only sur le code généré, mutations limitées au runtime (kill PID).

STEP 1 — Charger Project Config

Read workspace/stack/stack.md ## Project Config + ## Active Tech Specs pour identifier :

Backend stack → port défaut canonique :

Stack	Port défaut	Détection
`backend/kotlin-spring-boot`	`8080` (ou `44328` si override `server.port` dans `application.yml`)	grep `server.port:` dans `application.yml`
`backend/dotnet-minimalapi`	`5097`	grep `applicationUrl` dans `launchSettings.json`
`backend/python-fastapi`	`8000`	constante
`backend/node-express`	`3000`	constante

Frontend stack → port défaut :

Stack	Port défaut
`frontend/react` (Vite)	`5173` (ou override `server.port` dans `vite.config.ts`)
`frontend/vue` (Vite)	`5173`
`frontend/angular`	`4200`
`frontend/blazor-webassembly`	`5097`

Console → toujours 4000 (HTTPS) défini dans workspace/console/server.js, override possible via env PORT.

Si ## Project Config absent → continuer avec les defaults (cas /sdd-kill-server sans projet généré, où seule la console est susceptible de tourner).

STEP 2 — Résoudre les ports à killer

Calculer $PORTS = liste de tuples (label, port) selon les arguments :

ports = []
if "back" in args or args == []:
    ports.append(("Backend", read_backend_port_from_appsyml() or DEFAULT_BACK_PORT))
if "front" in args or args == []:
    ports.append(("Frontend", read_frontend_port_from_viteconfig() or DEFAULT_FRONT_PORT))
if "console" in args or args == []:
    ports.append(("Console", 4000))
if "--port" in args:
    ports.append(("Custom", int(arg_value_after_--port)))

Anti-derive : tout token inconnu → ERROR [INVALID_ARG] :

ERROR: /sdd-kill-server — argument invalide
CAUSE: [INVALID_ARG] "{arg}" ne matche pas back|front|console|--port
FIX: /sdd-kill-server [back] [front] [console] [--port N]

STEP 3 — Procédure de kill par port (Windows / Unix)

Use the Python-only runtime helper after resolving the selected ports:

\\bash python .sdd/python/sdd_scripts/server_control.py --port Backend:8080 --port Frontend:5173 --port Console:4000

Pour chaque (label, port) dans $PORTS, identifier le PID qui écoute, puis le tuer. Idempotent : un port libre = no-op silencieux.

3.1 — Détection PID (cross-platform)

Windows (via netstat) :

PID=$(netstat -ano | grep ":$PORT " | grep LISTENING | awk '{print ${{arg5}}}' | head -1)

Unix/macOS :

PID=$(lsof -ti :$PORT 2>/dev/null | head -1)
# Fallback : ss -tlnp | grep ":$PORT "

3.2 — Kill PID

Windows : taskkill //F //PID $PID 2>&1 (force kill, attend exit ≤ 5s).

Unix : kill -9 $PID 2>&1.

3.3 — Vérification post-kill

Attendre 1-2s puis re-checker le port :

sleep 1.5
STILL=$(netstat -ano | grep ":$PORT " | grep LISTENING | head -1)
if [ -n "$STILL" ]; then
  # Process zombie ou re-spawn (Spring Boot daemon ?) — tenter une 2e passe
  PID2=$(echo "$STILL" | awk '{print ${{arg5}}}')
  taskkill //F //PID "$PID2" 2>&1
fi

3.4 — Émettre 1 ligne par port

  ✓ Backend  (port 44328) → killed (PID 27012)
  ✓ Frontend (port 5185)  → killed (PID 29792)
  ⊘ Console  (port 4000)  → not running

STEP 4 — Cleanup orphelins (best-effort, optionnel)

Pour les stacks JVM (Spring Boot via Gradle), le wrapper gradlew peut forker un JVM enfant qui survit au kill du wrapper. Détection :

# Liste tous les java.exe avec dans la ligne de commande "DemoAppBack" ou app name
wmic process where "name='java.exe'" get processid,commandline 2>/dev/null | grep -i "{AppName}\|{BackendName}\|bootRun"

Tuer ces orphelins individuellement (même approche taskkill //F //PID).

Skip silencieux sur Unix (lsof + grep app name).

Cleanup analogue pour node.exe orphelins (Vite, Fastify) — match sur cwd ou commandline.

STEP 5 — Récap final (1 bloc compact ≤ 6 lignes)

🛑 /sdd-kill-server — 3 process arrêtés

  ✓ Backend  (port 44328) → killed (PID 27012, Java/Spring Boot)
  ✓ Frontend (port 5185)  → killed (PID 29792, Node/Vite)
  ✓ Console  (port 4000)  → killed (PID 16860, Node/Fastify)

Pour redémarrer : /sdd-serve

Cas où rien à killer (3 ports libres) :

⊘ /sdd-kill-server — aucun process à arrêter (3 ports libres)

Cas erreur (PID introuvable malgré port LISTENING) :

🟡 /sdd-kill-server — partiel
  ✓ Backend  → killed
  ⚠ Frontend (port 5185) → LISTENING mais PID introuvable (kill manuel requis : Task Manager → java.exe / node.exe)
  ✓ Console  → killed

Règles de cette commande

Pas de Q/R utilisateur. Sortie déterministe en 1 passe.
Idempotent : ports libres = no-op silencieux.
Best-effort sur orphelins : si JVM enfant Spring Boot survit, signaler via WARNING — pas d'erreur.
Pas de modification des configs/code — uniquement kill PID.
Pas d'arrêt de la DB PostgreSQL ou autres services système — out of scope.
Pas d'invocation d'agent — pure CLI / netstat / taskkill.

Implémentation référence (Claude Code via Bash tool)

L'orchestrateur (commande utilisateur) doit faire les opérations suivantes en une passe :

# Variables par défaut
BACK_PORT={{BACK_PORT}}
FRONT_PORT={{FRONT_PORT}}
CONSOLE_PORT={{CONSOLE_PORT}}

# Override depuis configs si disponibles
[ -f workspace/src/*/src/main/resources/application.yml ] && \
  BACK_PORT=$(grep -E "^\s*port:" workspace/src/*/src/main/resources/application.yml | head -1 | awk '{print $NF}')

[ -f workspace/src/*/vite.config.ts ] && \
  FRONT_PORT=$(grep -oE "port:\s*[0-9]+" workspace/src/*/vite.config.ts | head -1 | awk -F: '{print ${{arg2}}}' | tr -d ' ')

# Kill function
kill_port() {
  local LABEL=${{arg1}} PORT=${{arg2}}
  local PID=$(netstat -ano 2>/dev/null | grep ":{{PORT}} " | grep LISTENING | awk '{print ${{arg5}}}' | head -1)
  if [ -z "$PID" ]; then
    echo "  ⊘ {{LABEL}} (port {{PORT}}) → not running"
    return 0
  fi
  taskkill //F //PID "$PID" >/dev/null 2>&1 || kill -9 "$PID" 2>/dev/null
  sleep 1
  local STILL=$(netstat -ano 2>/dev/null | grep ":{{PORT}} " | grep LISTENING | awk '{print ${{arg5}}}' | head -1)
  if [ -n "$STILL" ]; then
    taskkill //F //PID "$STILL" >/dev/null 2>&1 || kill -9 "$STILL" 2>/dev/null
  fi
  echo "  ✓ {{LABEL}} (port {{PORT}}) → killed (PID {{PID}})"
}

# Apply
echo "🛑 /sdd-kill-server"
[[ "$*" == *"back"*    || "$*" == "" ]] && kill_port "Backend"  "$BACK_PORT"
[[ "$*" == *"front"*   || "$*" == "" ]] && kill_port "Frontend" "$FRONT_PORT"
[[ "$*" == *"console"* || "$*" == "" ]] && kill_port "Console"  "$CONSOLE_PORT"
echo ""
echo "Pour redémarrer : /sdd-serve"

Anti-patterns rejetés

❌ Kill par PID hardcodé (fragile entre runs)
❌ pkill -f node ou pkill -f java global (risque collatéral, kille des process non-SDD)
❌ Suppression des fichiers logs / output / build (out of scope)
❌ Arrêt de PostgreSQL ou autres services système (out of scope)
❌ Désinstallation de deps Node/Gradle (réservé Tech Lead manuel)

Use cases typiques

Restart propre : /sdd-kill-server && /sdd-serve (entre deux configs)
Nettoyage avant /dev-run : si build Gradle bloqué par JVM orphelin
Libérer 4000 après crash console : /sdd-kill-server --port 4000
Fin de session dev : /sdd-kill-server pour libérer toutes les ressources

Chat Output Protocol

Cette commande applique strictement .sdd/rules/output-protocol.md. Substance non dupliquée — la règle est SSoT.

Labels canoniques émis : [ANALYSIS] (label runtime, hors pipeline SDD) Plage de progression couverte : 0-100% (lifecycle serveurs)

Granularité cible : 2-3 updates (scan PIDs ports, kill, verdict). Format [ANALYSIS] Arrêt {service} (PID {N})... (X%).

Interdits stricts (cf. §5 du protocole) :

chemins de fichiers internes (workspace/..., .claude/...)
stdout/stderr de taskkill / kill / lsof
liste exhaustive des PIDs (compteur suffit)

Verdict final : 1 ligne récap. Exemple : [ANALYSIS] 3 process arrêtés (ports 8080, 5173, 4000). (100%). Ou : [ANALYSIS] Aucun process actif. (100%).

Bypass debug : SDD_CHAT_VERBOSE=1 → mode legacy verbose (§10).

Install sdd-kill-server and it becomes one more candidate the router can pick - when it fits.

A listing is a routing target with a manifest: what it does, which domains it covers, what it costs and who publishes it. Once installed it sits beside your own models and tools, is scored like any other candidate for each request, and shows up in the trace when it wins. Ratings come from workspaces that installed it, one per account.

Arguments: {{arguments}} # /sdd-kill-server — Arrête backend + frontend + console SDD > **Utilitaire runtime** (depuis v7.0.0) — pendant de `/sdd-serve`. > Stoppe les 3 process tournant en arrière-plan (Spring Boot / Vite / > Fastify console) en les identifiant par port. Idempotent. Aucun agent > invoqué, aucune mutation du code. Arrête les 3 process runtime du projet généré : 1. **Backend** Java / Spring Boot (port lu depuis `application.yml` ou défaut stack — `8080` Spring, `5097` .NET, `8000` FastAPI, etc.) 2. **Frontend** Node / Vite (port lu depuis `vite.config.ts` ou défaut `5173`) 3. **Console** SDD (Node / Fastify, port défaut `4000` ou env `PORT`) **Usage :** - `/sdd-kill-server` — kill les 3 - `/sdd-kill-server back` — backend seul - `/sdd-kill-server front` — frontend seul - `/sdd-kill-server console` — console seule - `/sdd-kill-server back front` — sous-ensemble - `/sdd-kill-server --port 5185` — kill un port arbitraire (utile pour processes orphelins après crash) **Read-only sur le code généré, mutations limitées au runtime (kill PID).** --- ## STEP 1 — Charger Project Config Read `workspace/stack/stack.md` `## Project Config` + `## Active Tech Specs` pour identifier : - **Backend stack** → port défaut canonique : | Stack | Port défaut | Détection | |---|---:|---| | `backend/kotlin-spring-boot` | `8080` (ou `44328` si override `server.port` dans `application.yml`) | grep `server.port:` dans `application.yml` | | `backend/dotnet-minimalapi` | `5097` | grep `applicationUrl` dans `launchSettings.json` | | `backend/python-fastapi` | `8000` | constante | | `backend/node-express` | `3000` | constante | - **Frontend stack** → port défaut : | Stack | Port défaut | |---|---:| | `frontend/react` (Vite) | `5173` (ou override `server.port` dans `vite.config.ts`) | | `frontend/vue` (Vite) | `5173` | | `frontend/angular` | `4200` | | `frontend/blazor-webassembly` | `5097` | - **Console** → toujours `4000` (HTTPS) défini dans `workspace/console/server.js`, override possible via env `PORT`. Si `## Project Config` absent → continuer avec les defaults (cas `/sdd-kill-server` sans projet généré, où seule la console est susceptible de tourner). --- ## STEP 2 — Résoudre les ports à killer Calculer `$PORTS = liste de tuples (label, port)` selon les arguments : ```python ports = [] if "back" in args or args == []: ports.append(("Backend", read_backend_port_from_appsyml() or DEFAULT_BACK_PORT)) if "front" in args or args == []: ports.append(("Frontend", read_frontend_port_from_viteconfig() or DEFAULT_FRONT_PORT)) if "console" in args or args == []: ports.append(("Console", 4000)) if "--port" in args: ports.append(("Custom", int(arg_value_after_--port))) ``` Anti-derive : tout token inconnu → ERROR `[INVALID_ARG]` : ``` ERROR: /sdd-kill-server — argument invalide CAUSE: [INVALID_ARG] "{arg}" ne matche pas back|front|console|--port FIX: /sdd-kill-server [back] [front] [console] [--port N] ``` --- ## STEP 3 — Procédure de kill par port (Windows / Unix) Use the Python-only runtime helper after resolving the selected ports: `\\bash python .sdd/python/sdd_scripts/server_control.py --port Backend:8080 --port Frontend:5173 --port Console:4000 ` Pour chaque `(label, port)` dans `$PORTS`, identifier le PID qui écoute, puis le tuer. Idempotent : un port libre = no-op silencieux. ### 3.1 — Détection PID (cross-platform) **Windows (via netstat)** : ```bash PID=$(netstat -ano | grep ":$PORT " | grep LISTENING | awk '{print ${{arg5}}}' | head -1) ``` **Unix/macOS** : ```bash PID=$(lsof -ti :$PORT 2>/dev/null | head -1) # Fallback : ss -tlnp | grep ":$PORT " ``` ### 3.2 — Kill PID **Windows** : `taskkill //F //PID $PID 2>&1` (force kill, attend exit ≤ 5s). **Unix** : `kill -9 $PID 2>&1`. ### 3.3 — Vérification post-kill Attendre 1-2s puis re-checker le port : ```bash sleep 1.5 STILL=$(netstat -ano | grep ":$PORT " | grep LISTENING | head -1) if [ -n "$STILL" ]; then # Process zombie ou re-spawn (Spring Boot daemon ?) — tenter une 2e passe PID2=$(echo "$STILL" | awk '{print ${{arg5}}}') taskkill //F //PID "$PID2" 2>&1 fi ``` ### 3.4 — Émettre 1 ligne par port ``` ✓ Backend (port 44328) → killed (PID 27012) ✓ Frontend (port 5185) → killed (PID 29792) ⊘ Console (port 4000) → not running ``` --- ## STEP 4 — Cleanup orphelins (best-effort, optionnel) Pour les stacks JVM (Spring Boot via Gradle), le wrapper `gradlew` peut forker un JVM enfant qui survit au kill du wrapper. Détection : ```bash # Liste tous les java.exe avec dans la ligne de commande "DemoAppBack" ou app name wmic process where "name='java.exe'" get processid,commandline 2>/dev/null | grep -i "{AppName}\|{BackendName}\|bootRun" ``` Tuer ces orphelins individuellement (même approche `taskkill //F //PID`). Skip silencieux sur Unix (lsof + grep app name). Cleanup analogue pour `node.exe` orphelins (Vite, Fastify) — match sur cwd ou commandline. --- ## STEP 5 — Récap final (1 bloc compact ≤ 6 lignes) ``` 🛑 /sdd-kill-server — 3 process arrêtés ✓ Backend (port 44328) → killed (PID 27012, Java/Spring Boot) ✓ Frontend (port 5185) → killed (PID 29792, Node/Vite) ✓ Console (port 4000) → killed (PID 16860, Node/Fastify) Pour redémarrer : /sdd-serve ``` Cas où rien à killer (3 ports libres) : ``` ⊘ /sdd-kill-server — aucun process à arrêter (3 ports libres) ``` Cas erreur (PID introuvable malgré port LISTENING) : ``` 🟡 /sdd-kill-server — partiel ✓ Backend → killed ⚠ Frontend (port 5185) → LISTENING mais PID introuvable (kill manuel requis : Task Manager → java.exe / node.exe) ✓ Console → killed ``` --- ## Règles de cette commande - **Pas de Q/R utilisateur.** Sortie déterministe en 1 passe. - **Idempotent** : ports libres = no-op silencieux. - **Best-effort sur orphelins** : si JVM enfant Spring Boot survit, signaler via WARNING — pas d'erreur. - **Pas de modification** des configs/code — uniquement kill PID. - **Pas d'arrêt de la DB** PostgreSQL ou autres services système — out of scope. - **Pas d'invocation d'agent** — pure CLI / netstat / taskkill. --- ## Implémentation référence (Claude Code via Bash tool) L'orchestrateur (commande utilisateur) doit faire les opérations suivantes en une passe : ```bash # Variables par défaut BACK_PORT={{BACK_PORT}} FRONT_PORT={{FRONT_PORT}} CONSOLE_PORT={{CONSOLE_PORT}} # Override depuis configs si disponibles [ -f workspace/src/*/src/main/resources/application.yml ] && \ BACK_PORT=$(grep -E "^\s*port:" workspace/src/*/src/main/resources/application.yml | head -1 | awk '{print $NF}') [ -f workspace/src/*/vite.config.ts ] && \ FRONT_PORT=$(grep -oE "port:\s*[0-9]+" workspace/src/*/vite.config.ts | head -1 | awk -F: '{print ${{arg2}}}' | tr -d ' ') # Kill function kill_port() { local LABEL=${{arg1}} PORT=${{arg2}} local PID=$(netstat -ano 2>/dev/null | grep ":{{PORT}} " | grep LISTENING | awk '{print ${{arg5}}}' | head -1) if [ -z "$PID" ]; then echo " ⊘ {{LABEL}} (port {{PORT}}) → not running" return 0 fi taskkill //F //PID "$PID" >/dev/null 2>&1 || kill -9 "$PID" 2>/dev/null sleep 1 local STILL=$(netstat -ano 2>/dev/null | grep ":{{PORT}} " | grep LISTENING | awk '{print ${{arg5}}}' | head -1) if [ -n "$STILL" ]; then taskkill //F //PID "$STILL" >/dev/null 2>&1 || kill -9 "$STILL" 2>/dev/null fi echo " ✓ {{LABEL}} (port {{PORT}}) → killed (PID {{PID}})" } # Apply echo "🛑 /sdd-kill-server" [[ "$*" == *"back"* || "$*" == "" ]] && kill_port "Backend" "$BACK_PORT" [[ "$*" == *"front"* || "$*" == "" ]] && kill_port "Frontend" "$FRONT_PORT" [[ "$*" == *"console"* || "$*" == "" ]] && kill_port "Console" "$CONSOLE_PORT" echo "" echo "Pour redémarrer : /sdd-serve" ``` --- ## Anti-patterns rejetés - ❌ Kill par PID hardcodé (fragile entre runs) - ❌ `pkill -f node` ou `pkill -f java` global (risque collatéral, kille des process non-SDD) - ❌ Suppression des fichiers logs / output / build (out of scope) - ❌ Arrêt de PostgreSQL ou autres services système (out of scope) - ❌ Désinstallation de deps Node/Gradle (réservé Tech Lead manuel) --- ## Use cases typiques 1. **Restart propre** : `/sdd-kill-server && /sdd-serve` (entre deux configs) 2. **Nettoyage avant `/dev-run`** : si build Gradle bloqué par JVM orphelin 3. **Libérer 4000 après crash console** : `/sdd-kill-server --port 4000` 4. **Fin de session dev** : `/sdd-kill-server` pour libérer toutes les ressources --- ## Chat Output Protocol > Cette commande applique strictement `.sdd/rules/output-protocol.md`. > Substance non dupliquée — la règle est SSoT. **Labels canoniques émis** : `[ANALYSIS]` (label runtime, hors pipeline SDD) **Plage de progression couverte** : `0-100%` (lifecycle serveurs) **Granularité cible** : 2-3 updates (scan PIDs ports, kill, verdict). Format `[ANALYSIS] Arrêt {service} (PID {N})... (X%)`. **Interdits stricts** (cf. §5 du protocole) : - chemins de fichiers internes (`workspace/...`, `.claude/...`) - stdout/stderr de `taskkill` / `kill` / `lsof` - liste exhaustive des PIDs (compteur suffit) **Verdict final** : 1 ligne récap. Exemple : `[ANALYSIS] 3 process arrêtés (ports 8080, 5173, 4000). (100%)`. Ou : `[ANALYSIS] Aucun process actif. (100%)`. **Bypass debug** : `SDD_CHAT_VERBOSE=1` → mode legacy verbose (§10).

{ "prompt": "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nArguments: {{arguments}}\n\n# /sdd-kill-server — Arrête backend + frontend + console SDD\n\n> **Utilitaire runtime** (depuis v7.0.0) — pendant de `/sdd-serve`.\n> Stoppe les 3 process tournant en arrière-plan (Spring Boot / Vite /\n> Fastify console) en les identifiant par port. Idempotent. Aucun agent\n> invoqué, aucune mutation du code.\n\nArrête les 3 process runtime du projet généré :\n1. **Backend** Java / Spring Boot (port lu depuis `application.yml` ou\n défaut stack — `8080` Spring, `5097` .NET, `8000` FastAPI, etc.)\n2. **Frontend** Node / Vite (port lu depuis `vite.config.ts` ou défaut `5173`)\n3. **Console** SDD (Node / Fastify, port défaut `4000` ou env `PORT`)\n\n**Usage :**\n- `/sdd-kill-server` — kill les 3\n- `/sdd-kill-server back` — backend seul\n- `/sdd-kill-server front` — frontend seul\n- `/sdd-kill-server console` — console seule\n- `/sdd-kill-server back front` — sous-ensemble\n- `/sdd-kill-server --port 5185` — kill un port arbitraire (utile pour processes orphelins après crash)\n\n**Read-only sur le code généré, mutations limitées au runtime (kill PID).**\n\n---\n\n## STEP 1 — Charger Project Config\n\nRead `workspace/stack/stack.md` `## Project Config` + `## Active Tech Specs`\npour identifier :\n- **Backend stack** → port défaut canonique :\n\n| Stack | Port défaut | Détection |\n|---|---:|---|\n| `backend/kotlin-spring-boot` | `8080` (ou `44328` si override `server.port` dans `application.yml`) | grep `server.port:` dans `application.yml` |\n| `backend/dotnet-minimalapi` | `5097` | grep `applicationUrl` dans `launchSettings.json` |\n| `backend/python-fastapi` | `8000` | constante |\n| `backend/node-express` | `3000` | constante |\n\n- **Frontend stack** → port défaut :\n\n| Stack | Port défaut |\n|---|---:|\n| `frontend/react` (Vite) | `5173` (ou override `server.port` dans `vite.config.ts`) |\n| `frontend/vue` (Vite) | `5173` |\n| `frontend/angular` | `4200` |\n| `frontend/blazor-webassembly` | `5097` |\n\n- **Console** → toujours `4000` (HTTPS) défini dans `workspace/console/server.js`,\n override possible via env `PORT`.\n\nSi `## Project Config` absent → continuer avec les defaults (cas `/sdd-kill-server`\nsans projet généré, où seule la console est susceptible de tourner).\n\n---\n\n## STEP 2 — Résoudre les ports à killer\n\nCalculer `$PORTS = liste de tuples (label, port)` selon les arguments :\n\n```python\nports = []\nif \"back\" in args or args == []:\n ports.append((\"Backend\", read_backend_port_from_appsyml() or DEFAULT_BACK_PORT))\nif \"front\" in args or args == []:\n ports.append((\"Frontend\", read_frontend_port_from_viteconfig() or DEFAULT_FRONT_PORT))\nif \"console\" in args or args == []:\n ports.append((\"Console\", 4000))\nif \"--port\" in args:\n ports.append((\"Custom\", int(arg_value_after_--port)))\n```\n\nAnti-derive : tout token inconnu → ERROR `[INVALID_ARG]` :\n```\nERROR: /sdd-kill-server — argument invalide\nCAUSE: [INVALID_ARG] \"{arg}\" ne matche pas back|front|console|--port\nFIX: /sdd-kill-server [back] [front] [console] [--port N]\n```\n\n---\n\n## STEP 3 — Procédure de kill par port (Windows / Unix)\n\nUse the Python-only runtime helper after resolving the selected ports:\n\n`\\\\bash\npython .sdd/python/sdd_scripts/server_control.py --port Backend:8080 --port Frontend:5173 --port Console:4000\n`\n\n\nPour chaque `(label, port)` dans `$PORTS`, identifier le PID qui écoute,\npuis le tuer. Idempotent : un port libre = no-op silencieux.\n\n### 3.1 — Détection PID (cross-platform)\n\n**Windows (via netstat)** :\n```bash\nPID=$(netstat -ano | grep \":$PORT \" | grep LISTENING | awk '{print ${{arg5}}}' | head -1)\n```\n\n**Unix/macOS** :\n```bash\nPID=$(lsof -ti :$PORT 2>/dev/null | head -1)\n# Fallback : ss -tlnp | grep \":$PORT \"\n```\n\n### 3.2 — Kill PID\n\n**Windows** : `taskkill //F //PID $PID 2>&1` (force kill, attend exit ≤ 5s).\n\n**Unix** : `kill -9 $PID 2>&1`.\n\n### 3.3 — Vérification post-kill\n\nAttendre 1-2s puis re-checker le port :\n```bash\nsleep 1.5\nSTILL=$(netstat -ano | grep \":$PORT \" | grep LISTENING | head -1)\nif [ -n \"$STILL\" ]; then\n # Process zombie ou re-spawn (Spring Boot daemon ?) — tenter une 2e passe\n PID2=$(echo \"$STILL\" | awk '{print ${{arg5}}}')\n taskkill //F //PID \"$PID2\" 2>&1\nfi\n```\n\n### 3.4 — Émettre 1 ligne par port\n\n```\n ✓ Backend (port 44328) → killed (PID 27012)\n ✓ Frontend (port 5185) → killed (PID 29792)\n ⊘ Console (port 4000) → not running\n```\n\n---\n\n## STEP 4 — Cleanup orphelins (best-effort, optionnel)\n\nPour les stacks JVM (Spring Boot via Gradle), le wrapper `gradlew` peut\nforker un JVM enfant qui survit au kill du wrapper. Détection :\n\n```bash\n# Liste tous les java.exe avec dans la ligne de commande \"DemoAppBack\" ou app name\nwmic process where \"name='java.exe'\" get processid,commandline 2>/dev/null | grep -i \"{AppName}\\|{BackendName}\\|bootRun\"\n```\n\nTuer ces orphelins individuellement (même approche `taskkill //F //PID`).\n\nSkip silencieux sur Unix (lsof + grep app name).\n\nCleanup analogue pour `node.exe` orphelins (Vite, Fastify) — match sur\ncwd ou commandline.\n\n---\n\n## STEP 5 — Récap final (1 bloc compact ≤ 6 lignes)\n\n```\n🛑 /sdd-kill-server — 3 process arrêtés\n\n ✓ Backend (port 44328) → killed (PID 27012, Java/Spring Boot)\n ✓ Frontend (port 5185) → killed (PID 29792, Node/Vite)\n ✓ Console (port 4000) → killed (PID 16860, Node/Fastify)\n\nPour redémarrer : /sdd-serve\n```\n\nCas où rien à killer (3 ports libres) :\n```\n⊘ /sdd-kill-server — aucun process à arrêter (3 ports libres)\n```\n\nCas erreur (PID introuvable malgré port LISTENING) :\n```\n🟡 /sdd-kill-server — partiel\n ✓ Backend → killed\n ⚠ Frontend (port 5185) → LISTENING mais PID introuvable (kill manuel requis : Task Manager → java.exe / node.exe)\n ✓ Console → killed\n```\n\n---\n\n## Règles de cette commande\n\n- **Pas de Q/R utilisateur.** Sortie déterministe en 1 passe.\n- **Idempotent** : ports libres = no-op silencieux.\n- **Best-effort sur orphelins** : si JVM enfant Spring Boot survit, signaler\n via WARNING — pas d'erreur.\n- **Pas de modification** des configs/code — uniquement kill PID.\n- **Pas d'arrêt de la DB** PostgreSQL ou autres services système — out of scope.\n- **Pas d'invocation d'agent** — pure CLI / netstat / taskkill.\n\n---\n\n## Implémentation référence (Claude Code via Bash tool)\n\nL'orchestrateur (commande utilisateur) doit faire les opérations\nsuivantes en une passe :\n\n```bash\n# Variables par défaut\nBACK_PORT={{BACK_PORT}}\nFRONT_PORT={{FRONT_PORT}}\nCONSOLE_PORT={{CONSOLE_PORT}}\n\n# Override depuis configs si disponibles\n[ -f workspace/src/*/src/main/resources/application.yml ] && \\\n BACK_PORT=$(grep -E \"^\\s*port:\" workspace/src/*/src/main/resources/application.yml | head -1 | awk '{print $NF}')\n\n[ -f workspace/src/*/vite.config.ts ] && \\\n FRONT_PORT=$(grep -oE \"port:\\s*[0-9]+\" workspace/src/*/vite.config.ts | head -1 | awk -F: '{print ${{arg2}}}' | tr -d ' ')\n\n# Kill function\nkill_port() {\n local LABEL=${{arg1}} PORT=${{arg2}}\n local PID=$(netstat -ano 2>/dev/null | grep \":{{PORT}} \" | grep LISTENING | awk '{print ${{arg5}}}' | head -1)\n if [ -z \"$PID\" ]; then\n echo \" ⊘ {{LABEL}} (port {{PORT}}) → not running\"\n return 0\n fi\n taskkill //F //PID \"$PID\" >/dev/null 2>&1 || kill -9 \"$PID\" 2>/dev/null\n sleep 1\n local STILL=$(netstat -ano 2>/dev/null | grep \":{{PORT}} \" | grep LISTENING | awk '{print ${{arg5}}}' | head -1)\n if [ -n \"$STILL\" ]; then\n taskkill //F //PID \"$STILL\" >/dev/null 2>&1 || kill -9 \"$STILL\" 2>/dev/null\n fi\n echo \" ✓ {{LABEL}} (port {{PORT}}) → killed (PID {{PID}})\"\n}\n\n# Apply\necho \"🛑 /sdd-kill-server\"\n[[ \"$*\" == *\"back\"* || \"$*\" == \"\" ]] && kill_port \"Backend\" \"$BACK_PORT\"\n[[ \"$*\" == *\"front\"* || \"$*\" == \"\" ]] && kill_port \"Frontend\" \"$FRONT_PORT\"\n[[ \"$*\" == *\"console\"* || \"$*\" == \"\" ]] && kill_port \"Console\" \"$CONSOLE_PORT\"\necho \"\"\necho \"Pour redémarrer : /sdd-serve\"\n```\n\n---\n\n## Anti-patterns rejetés\n\n- ❌ Kill par PID hardcodé (fragile entre runs)\n- ❌ `pkill -f node` ou `pkill -f java` global (risque collatéral, kille des process non-SDD)\n- ❌ Suppression des fichiers logs / output / build (out of scope)\n- ❌ Arrêt de PostgreSQL ou autres services système (out of scope)\n- ❌ Désinstallation de deps Node/Gradle (réservé Tech Lead manuel)\n\n---\n\n## Use cases typiques\n\n1. **Restart propre** : `/sdd-kill-server && /sdd-serve` (entre deux configs)\n2. **Nettoyage avant `/dev-run`** : si build Gradle bloqué par JVM orphelin\n3. **Libérer 4000 après crash console** : `/sdd-kill-server --port 4000`\n4. **Fin de session dev** : `/sdd-kill-server` pour libérer toutes les ressources\n\n---\n\n## Chat Output Protocol\n\n> Cette commande applique strictement `.sdd/rules/output-protocol.md`.\n> Substance non dupliquée — la règle est SSoT.\n\n**Labels canoniques émis** : `[ANALYSIS]` (label runtime, hors pipeline\nSDD)\n**Plage de progression couverte** : `0-100%` (lifecycle serveurs)\n\n**Granularité cible** : 2-3 updates (scan PIDs ports, kill, verdict).\nFormat `[ANALYSIS] Arrêt {service} (PID {N})... (X%)`.\n\n**Interdits stricts** (cf. §5 du protocole) :\n- chemins de fichiers internes (`workspace/...`, `.claude/...`)\n- stdout/stderr de `taskkill` / `kill` / `lsof`\n- liste exhaustive des PIDs (compteur suffit)\n\n**Verdict final** : 1 ligne récap. Exemple :\n`[ANALYSIS] 3 process arrêtés (ports 8080, 5173, 4000). (100%)`.\nOu : `[ANALYSIS] Aucun process actif. (100%)`.\n\n**Bypass debug** : `SDD_CHAT_VERBOSE=1` → mode legacy verbose (§10).", "variables": [ "arguments", "arg5", "BACK_PORT", "FRONT_PORT", "CONSOLE_PORT", "arg2", "arg1", "PORT", "LABEL", "PID" ], "notes": "Arguments: ${arguments}", "metadata": { "source": { "provider": "github-codex-prompts", "repository": "https://github.com/zekiriabd/SDD-Pro", "path": ".codex/prompts/sdd-kill-server.md", "ref": "d61307fb26d4341b99c51c95629b6c43c5c35451", "url": "https://github.com/zekiriabd/SDD-Pro/blob/d61307fb26d4341b99c51c95629b6c43c5c35451/.codex/prompts/sdd-kill-server.md", "key": "zekiriabd/SDD-Pro/.codex/prompts/sdd-kill-server.md" } } }

sdd-kill-server

About