feat: stop container

Author: Annonnymmousss

src/backend/health-api.ts

@@ -6,17 +6,17 @@ import {
     type TimeStep,
     type TimeRange,
 } from "./utils/container-health.ts";
-import { restartContainer, getRestartCount } from "./utils/auto-restart.ts";
+import { restartContainer, stopContainer, getRestartCount, getStopCount } from "./utils/auto-restart.ts";
 import { getMonitorStatus, triggerHealthCheck } from "./health-monitor.ts";
 import { checkJWT } from "./utils/jwt.ts";
 
 const TIME_RANGE_PRESETS: Record<TimeStep, TimeRange> = {
-    '1s': { step: '1s', duration: '5m' },   
-    '15s': { step: '15s', duration: '15m' }, 
-    '1m': { step: '1m', duration: '1h' },    
-    '5m': { step: '5m', duration: '6h' },    
-    '1h': { step: '1h', duration: '24h' },   
-    '1d': { step: '1d', duration: '7d' },    
+    '1s': { step: '1s', duration: '5m' },
+    '15s': { step: '15s', duration: '15m' },
+    '1m': { step: '1m', duration: '1h' },
+    '5m': { step: '5m', duration: '6h' },
+    '1h': { step: '1h', duration: '24h' },
+    '1d': { step: '1d', duration: '7d' },
 };
 
 
@@ -44,6 +44,7 @@ export async function getContainerHealth(ctx: Context): Promise<void> {
             memoryPercent: Math.round(c.memoryPercent * 100) / 100,
             memoryUsageMB: Math.round(c.memoryUsage / (1024 * 1024)),
             restartCount: getRestartCount(c.name),
+            stopCount: getStopCount(c.name),
             isHealthy: !isUnhealthy(c),
             lastUpdated: c.lastUpdated.toISOString(),
         })),
@@ -160,6 +161,42 @@ export async function restartContainerHandler(ctx: Context): Promise<void> {
     }
 }
 
+export async function stopContainerHandler(ctx: Context): Promise<void> {
+    const subdomain = ctx.params.subdomain;
+
+    const body = await ctx.request.body().value;
+    let document;
+    try {
+        document = typeof body === 'string' ? JSON.parse(body) : body;
+    } catch {
+        document = body;
+    }
+
+    const author = document?.author;
+    const token = document?.token;
+    const provider = document?.provider;
+
+    if (author !== await checkJWT(provider, token)) {
+        ctx.throw(401);
+    }
+
+    try {
+        await stopContainer(subdomain);
+
+        ctx.response.headers.set("Access-Control-Allow-Origin", "*");
+        ctx.response.body = {
+            status: "success",
+            message: `Container ${subdomain} stop initiated`,
+        };
+    } catch (error) {
+        ctx.response.status = 500;
+        ctx.response.body = {
+            status: "error",
+            message: `Failed to stop ${subdomain}: ${error}`,
+        };
+    }
+}
+
 
 export async function triggerHealthCheckHandler(ctx: Context): Promise<void> {
     const body = await ctx.request.body().value;

src/backend/server.ts

@@ -19,6 +19,7 @@ import {
   getContainerMetrics,
   getHealthDashboard,
   restartContainerHandler,
+  stopContainerHandler,
   triggerHealthCheckHandler,
 } from "./health-api.ts";
 import { startHealthMonitor } from "./health-monitor.ts";
@@ -76,6 +77,7 @@ router
   .get("/health/summary", (ctx) => getHealthDashboard(ctx))
   .get("/health/:subdomain/metrics", (ctx) => getContainerMetrics(ctx))
   .post("/health/:subdomain/restart", (ctx) => restartContainerHandler(ctx))
+  .post("/health/:subdomain/stop", (ctx) => stopContainerHandler(ctx))
   .post("/health/check", (ctx) => triggerHealthCheckHandler(ctx));
 
 app.use(oakCors());

src/backend/shell_scripts/restart.sh

@@ -13,3 +13,9 @@ arg1=$1
 echo "Restarting... $arg1"
 
 sudo docker restart $arg1
+
+# Re-enable nginx routing if it was previously stopped
+if [ ! -f "/etc/nginx/sites-enabled/$arg1.conf" ] && [ -f "/etc/nginx/sites-available/$arg1.conf" ]; then
+    sudo ln -s /etc/nginx/sites-available/$arg1.conf /etc/nginx/sites-enabled/$arg1.conf
+    sudo systemctl reload nginx
+fi

src/backend/shell_scripts/stop.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+# This script takes in 1 command line argument (the container name)
+
+id -u
+if [ "$#" -ne 1 ]; then
+    echo "Usage: $0 container_name"
+    exit 1
+fi
+
+arg1=$1
+
+echo "Stopping... $arg1"
+
+sudo docker stop $arg1
+
+# Disable nginx routing for this domain so it doesn't return 502
+if [ -f "/etc/nginx/sites-enabled/$arg1.conf" ]; then
+    sudo rm /etc/nginx/sites-enabled/$arg1.conf
+    sudo systemctl reload nginx
+fi

src/backend/tests/container-health.test.ts

@@ -656,6 +656,74 @@ Deno.test("getRestartCount - tracks multiple containers separately", () => {
     assertEquals(getRestartCount("container-b"), 5);
 });
 
+Deno.test("getStopCount - returns correct count", () => {
+    const stopCounts = new Map<string, { count: number; lastStop: Date }>();
+    stopCounts.set("test-container", { count: 3, lastStop: new Date() });
+
+    const getStopCount = (containerName: string): number => {
+        return stopCounts.get(containerName)?.count || 0;
+    };
+
+    assertEquals(getStopCount("test-container"), 3);
+});
+
+Deno.test("restartContainer - updates restart count", async () => {
+    const restartCounts = new Map<string, { count: number; lastRestart: Date }>();
+    restartCounts.set("test-container", { count: 1, lastRestart: new Date(Date.now() - 10000) });
+
+    let execCalledWith = "";
+    const mockExec = async (cmd: string) => {
+        execCalledWith = cmd;
+    };
+
+    const restartContainer = async (containerName: string): Promise<void> => {
+        await mockExec(`bash -c "echo 'bash ../../src/backend/shell_scripts/restart.sh ${containerName}' > /hostpipe/pipe"`);
+        const current = restartCounts.get(containerName);
+        restartCounts.set(containerName, {
+            count: (current?.count || 0) + 1,
+            lastRestart: new Date(),
+        });
+    };
+
+    const before = new Date();
+    await restartContainer("test-container");
+    const after = new Date();
+
+    assertEquals(execCalledWith, `bash -c "echo 'bash ../../src/backend/shell_scripts/restart.sh test-container' > /hostpipe/pipe"`);
+
+    const stats = restartCounts.get("test-container");
+    assertExists(stats);
+    assertEquals(stats.count, 2);
+    assert(stats.lastRestart.getTime() >= before.getTime() && stats.lastRestart.getTime() <= after.getTime());
+});
+
+Deno.test("stopContainer - updates stop count and calls stop script", async () => {
+    const stopCounts = new Map<string, { count: number; lastStop: Date }>();
+    let execCalledWith = "";
+    const mockExec = async (cmd: string) => {
+        execCalledWith = cmd;
+    };
+
+    const stopContainer = async (containerName: string): Promise<void> => {
+        await mockExec(`bash -c "echo 'bash ../../src/backend/shell_scripts/stop.sh ${containerName}' > /hostpipe/pipe"`);
+        const current = stopCounts.get(containerName);
+        stopCounts.set(containerName, {
+            count: (current?.count || 0) + 1,
+            lastStop: new Date(),
+        });
+    };
+
+    const before = new Date();
+    await stopContainer("test-container");
+    const after = new Date();
+
+    assertEquals(execCalledWith, `bash -c "echo 'bash ../../src/backend/shell_scripts/stop.sh test-container' > /hostpipe/pipe"`);
+    const stats = stopCounts.get("test-container");
+    assertExists(stats);
+    assertEquals(stats.count, 1);
+    assert(stats.lastStop.getTime() >= before.getTime() && stats.lastStop.getTime() <= after.getTime());
+});
+
 Deno.test("ContainerStats - validates all required fields", () => {
     const validStats: ContainerStats = {
         containerId: "abc123",

src/backend/utils/auto-restart.ts

@@ -1,11 +1,16 @@
 import { exec } from "../dependencies.ts";
 
 const restartCounts = new Map<string, { count: number; lastRestart: Date }>();
+const stopCounts = new Map<string, { count: number; lastStop: Date }>();
 
 export function getRestartCount(containerName: string): number {
     return restartCounts.get(containerName)?.count || 0;
 }
 
+export function getStopCount(containerName: string): number {
+    return stopCounts.get(containerName)?.count || 0;
+}
+
 export async function restartContainer(containerName: string): Promise<void> {
     try {
         await exec(
@@ -23,3 +28,20 @@ export async function restartContainer(containerName: string): Promise<void> {
         throw error;
     }
 }
+
+export async function stopContainer(containerName: string): Promise<void> {
+    try {
+        await exec(
+            `bash -c "echo 'bash ../../src/backend/shell_scripts/stop.sh ${containerName}' > /hostpipe/pipe"`
+        );
+
+        const current = stopCounts.get(containerName);
+        stopCounts.set(containerName, {
+            count: (current?.count || 0) + 1,
+            lastStop: new Date(),
+        });
+    } catch (error) {
+        console.error(`Failed to stop ${containerName}:`, error);
+        throw error;
+    }
+}

src/frontend/src/components/ContainerHealth.vue

@@ -77,13 +77,17 @@
           </div>
 
           <div class="container-stats">
-            <span><strong>Restarts:</strong> {{ container.restartCount }}</span>
+            <span><strong>Restarts:</strong> {{ container.restartCount }}</span> | 
+            <span><strong>Stops:</strong> {{ container.stopCount }}</span>
           </div>
 
           <div class="container-actions">
             <button @click="viewMetrics(container)" class="view-btn">
               View Metrics
             </button>
+            <button @click="stopContainer(container)" class="stop-btn">
+              Stop
+            </button>
             <button @click="restartContainer(container)" class="restart-btn">
               Restart
             </button>
@@ -140,6 +144,7 @@ interface Container {
   memoryPercent: number;
   memoryUsageMB: number;
   restartCount: number;
+  stopCount: number;
   isHealthy: boolean;
   lastUpdated: string;
 }
@@ -342,26 +347,49 @@ export default defineComponent({
     };
 
     const restartContainer = async (container: Container) => {
-      if (!confirm(`Restart container ${container.subdomain}?`)) return;
+      const containerIdentifier = container.subdomain || container.name;
+      if (!confirm(`Restart container ${containerIdentifier}?`)) return;
 
       try {
         const token = localStorage.getItem('JWTUser') || '';
         const provider = localStorage.getItem('provider') || '';
         
-        await fetch(`${BACKEND_URL}/health/${container.subdomain}/restart`, {
+        await fetch(`${BACKEND_URL}/health/${containerIdentifier}/restart`, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({ author: username.value, token: token, provider }),
         });
 
-        alert(`Restart initiated for ${container.subdomain}`);
+        alert(`Restart initiated for ${containerIdentifier}`);
         fetchHealth();
       } catch (error) {
         console.error('Failed to restart:', error);
         alert('Failed to restart container');
       }
     };
 
+    const stopContainer = async (container: Container) => {
+      const containerIdentifier = container.subdomain || container.name;
+      if (!confirm(`Stop container ${containerIdentifier}?`)) return;
+
+      try {
+        const token = localStorage.getItem('JWTUser') || '';
+        const provider = localStorage.getItem('provider') || '';
+        
+        await fetch(`${BACKEND_URL}/health/${containerIdentifier}/stop`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ author: username.value, token: token, provider }),
+        });
+
+        alert(`Stop initiated for ${containerIdentifier}`);
+        fetchHealth();
+      } catch (error) {
+        console.error('Failed to stop:', error);
+        alert('Failed to stop container');
+      }
+    };
+
     onMounted(async() => {
       await fetchUsername();
       fetchHealth();
@@ -382,6 +410,7 @@ export default defineComponent({
       closeMetrics,
       loadMetrics,
       restartContainer,
+      stopContainer,
     };
   },
 });
@@ -570,7 +599,7 @@ export default defineComponent({
   gap: 0.75rem;
 }
 
-.view-btn, .restart-btn {
+.view-btn, .restart-btn, .stop-btn {
   flex: 1;
   padding: 0.5rem;
   border-radius: 6px;
@@ -585,6 +614,12 @@ export default defineComponent({
   border: 1px solid #bfdbfe;
 }
 
+.stop-btn {
+  background: #fee2e2;
+  color: #991b1b;
+  border: 1px solid #fecaca;
+}
+
 .restart-btn {
   background: #fef3c7;
   color: #92400e;