Fix Kubernetes scenario issues

- Mount Docker socket for k8s scenarios to enable kind cluster creation
- Move setup.sh execution from build-time to runtime via entrypoint script
- Add automatic Docker network creation on server startup
- Add Docker image validation before container creation
- Improve error handling and logging throughout the server
- Fix missing dependencies in base Dockerfile (lsb-release, unzip)

Resolves GitHub issues #6, #7, #8, #9, #10

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: alanops

docker/Dockerfile.scenario-base

@@ -1,25 +1,11 @@
 FROM ubuntu:22.04
 
+RUN apt-get update && apt-get install -y curl gnupg
+RUN curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.28/deb/Release.key | gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
+RUN echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.28/deb/ /' | tee /etc/apt/sources.list.d/kubernetes.list
+
 # Install base tools
-RUN apt-get update && apt-get install -y \
-    curl \
-    wget \
-    git \
-    vim \
-    nano \
-    htop \
-    net-tools \
-    dnsutils \
-    traceroute \
-    telnet \
-    jq \
-    python3 \
-    python3-pip \
-    nodejs \
-    npm \
-    docker.io \
-    kubectl \
-    && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y     curl     wget     git     vim     nano     htop     net-tools     dnsutils     traceroute     telnet     jq     python3     python3-pip     nodejs     npm     docker.io     kubectl     lsb-release     unzip     && rm -rf /var/lib/apt/lists/*
 
 # Install Terraform
 RUN wget -O- https://apt.releases.hashicorp.com/gpg | apt-key add - \

next-env.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/basic-features/typescript for more information.

scenarios/kubernetes/keycloak-crashloop/Dockerfile

@@ -12,12 +12,15 @@ COPY --chown=devops:devops setup.sh /home/devops/
 COPY --chown=devops:devops manifests/ /home/devops/manifests/
 COPY --chown=devops:devops solution/ /home/devops/.solution/
 
-USER devops
+USER root
+
+# Copy entrypoint script
+COPY --chown=devops:devops entrypoint.sh /home/devops/
 
 # Make scripts executable
-RUN chmod +x /home/devops/setup.sh
+RUN chmod +x /home/devops/setup.sh /home/devops/entrypoint.sh
 
-# Initialize the broken scenario
-RUN /home/devops/setup.sh
+USER devops
 
-CMD ["/bin/bash"]
+# Use entrypoint to run setup at container start time
+ENTRYPOINT ["/home/devops/entrypoint.sh"]

scenarios/kubernetes/keycloak-crashloop/entrypoint.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+# Run the setup script to initialize the scenario
+/home/devops/setup.sh
+
+# Keep the container running with bash
+exec /bin/bash

src/server/index.ts

@@ -35,8 +35,20 @@ io.on('connection', (socket) => {
 
   const scenarioId = socket.handshake.query.scenarioId as string
 
+  if (!scenarioId) {
+    socket.emit('output', '\\r\\nError: No scenario ID provided\\r\\n')
+    socket.disconnect()
+    return
+  }
+  
+  console.log(`Starting scenario '${scenarioId}' for socket ${socket.id}`)
+  
   // Start a new container for this scenario
-  startScenarioContainer(socket, scenarioId)
+  startScenarioContainer(socket, scenarioId).catch((error) => {
+    console.error(`Failed to start scenario ${scenarioId}:`, error)
+    socket.emit('output', `\\r\\nError: Failed to start scenario: ${error.message}\\r\\n`)
+    socket.disconnect()
+  })
 
   socket.on('input', (data: string) => {
     const session = sessions.get(socket.id)
@@ -58,7 +70,16 @@ io.on('connection', (socket) => {
   })
 })
 
-function startScenarioContainer(socket: any, scenarioId: string) {
+async function checkDockerImage(imageName: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const checkImage = spawn('docker', ['image', 'inspect', imageName])
+    checkImage.on('exit', (code) => {
+      resolve(code === 0)
+    })
+  })
+}
+
+async function startScenarioContainer(socket: any, scenarioId: string) {
   // Map scenario IDs to Docker images
   const scenarioImages: Record<string, string> = {
     'k8s-crashloop': 'devopslearn/scenario-keycloak-crashloop',
@@ -69,15 +90,35 @@ function startScenarioContainer(socket: any, scenarioId: string) {
 
   const imageName = scenarioImages[scenarioId] || 'devopslearn/scenario-base'
 
-  // Start Docker container with TTY
-  const dockerProcess = spawn('docker', [
+  // Check if Docker image exists
+  const imageExists = await checkDockerImage(imageName)
+  if (!imageExists) {
+    socket.emit('output', `\r\nError: Docker image '${imageName}' not found.\r\n`)
+    socket.emit('output', `Please run 'make scenario-build' to build the scenario images.\r\n`)
+    socket.emit('output', `\r\nDisconnecting...\r\n`)
+    socket.disconnect()
+    return
+  }
+  
+  // Build Docker run arguments
+  const args = [
     'run',
     '-it',
     '--rm',
     '--name', `devops-dojo-${socket.id}`,
     '--network', 'devops-dojo-net',
-    imageName
-  ], {
+  ]
+  
+  // Mount Docker socket for Kubernetes scenarios that need it
+  const k8sScenarios = ['k8s-crashloop', 'k8s-dns', 'k8s-istio']
+  if (k8sScenarios.includes(scenarioId)) {
+    args.push('-v', '/var/run/docker.sock:/var/run/docker.sock')
+  }
+  
+  args.push(imageName)
+  
+  // Start Docker container with TTY
+  const dockerProcess = spawn('docker', args, {
     env: { ...process.env, TERM: 'xterm-256color' }
   })
 
@@ -94,31 +135,115 @@ function startScenarioContainer(socket: any, scenarioId: string) {
   })
 
   dockerProcess.stderr.on('data', (data) => {
-    socket.emit('output', data.toString())
+    const errorMessage = data.toString()
+    console.error(`Container ${scenarioId} stderr:`, errorMessage)
+    socket.emit('output', errorMessage)
+  })
+  
+  dockerProcess.on('error', (error) => {
+    console.error(`Failed to start container for scenario ${scenarioId}:`, error)
+    socket.emit('output', `\\r\\nError: Failed to start container: ${error.message}\\r\\n`)
+    sessions.delete(socket.id)
   })
 
   dockerProcess.on('exit', (code) => {
+    console.log(`Container for scenario ${scenarioId} exited with code ${code}`)
     socket.emit('output', `\\r\\nContainer exited with code ${code}\\r\\n`)
     sessions.delete(socket.id)
   })
 
-  // Notify client that scenario is ready
+  // Notify client that scenario is ready after a short delay
+  // TODO: Replace with actual readiness check
   setTimeout(() => {
-    socket.emit('scenario-ready')
+    // Check if container is still running
+    if (sessions.has(socket.id)) {
+      socket.emit('scenario-ready')
+      console.log(`Scenario ${scenarioId} is ready for socket ${socket.id}`)
+    }
   }, 2000)
 }
 
 function cleanupSession(socketId: string) {
   const session = sessions.get(socketId)
   if (session) {
+    console.log(`Cleaning up session for ${socketId}, scenario: ${session.scenarioId}`)
     // Kill the Docker container
-    spawn('docker', ['kill', session.containerId])
+    const killProcess = spawn('docker', ['kill', session.containerId])
+    killProcess.on('error', (error) => {
+      console.error(`Error killing container ${session.containerId}:`, error)
+    })
     sessions.delete(socketId)
   }
 }
 
+// Check if Docker daemon is accessible
+async function checkDockerDaemon(): Promise<boolean> {
+  return new Promise((resolve) => {
+    const checkDocker = spawn('docker', ['version'])
+    checkDocker.on('exit', (code) => {
+      resolve(code === 0)
+    })
+    checkDocker.on('error', () => {
+      resolve(false)
+    })
+  })
+}
+
+// Ensure Docker network exists
+async function ensureDockerNetwork() {
+  try {
+    // Check if network exists
+    const checkNetwork = spawn('docker', ['network', 'inspect', 'devops-dojo-net'])
+    
+    await new Promise((resolve) => {
+      checkNetwork.on('exit', (code) => {
+        if (code !== 0) {
+          // Network doesn't exist, create it
+          console.log('Creating Docker network: devops-dojo-net')
+          const createNetwork = spawn('docker', ['network', 'create', 'devops-dojo-net'])
+          createNetwork.on('exit', (createCode) => {
+            if (createCode === 0) {
+              console.log('Docker network created successfully')
+            } else {
+              console.error('Failed to create Docker network')
+            }
+            resolve(null)
+          })
+        } else {
+          console.log('Docker network already exists')
+          resolve(null)
+        }
+      })
+    })
+  } catch (error) {
+    console.error('Error checking/creating Docker network:', error)
+  }
+}
+
 const PORT = process.env.PORT || 3001
 
-server.listen(PORT, () => {
-  console.log(`DevOps Dojo server running on port ${PORT}`)
+// Initialize server with Docker checks
+async function initializeServer() {
+  console.log('Checking Docker daemon...')
+  const dockerAvailable = await checkDockerDaemon()
+  
+  if (!dockerAvailable) {
+    console.error('Error: Docker daemon is not accessible')
+    console.error('Please ensure Docker is installed and running')
+    process.exit(1)
+  }
+  
+  console.log('Docker daemon is accessible')
+  
+  await ensureDockerNetwork()
+  
+  server.listen(PORT, () => {
+    console.log(`DevOps Dojo server running on port ${PORT}`)
+  })
+}
+
+// Start the server
+initializeServer().catch((error) => {
+  console.error('Failed to initialize server:', error)
+  process.exit(1)
 })