feat: Add RAM and CPU resource validation for container deployments

apps/agent-app/src/app.module.ts

@@ -7,7 +7,7 @@ import { HealthController } from "./health/health.controller";
 import { FilesystemService } from "./filesystem/filesystem.service";
 import { DeployTemplateExecutor } from "./executors/deploy-template.executor";
 import { TraefikProxyService } from "./proxy/traefik-proxy.service";
-import { PortAvailabilityService } from "./port-availability/port-availability.service";
+import { ResourceAvailabilityService } from "./resource-availability/resource-availability.service";
 import { TerminalService } from "./terminal/terminal.service";
 import {
   ComposeParserModule,
@@ -34,7 +34,7 @@ import {
     FilesystemService,
     DeployTemplateExecutor,
     TraefikProxyService,
-    PortAvailabilityService,
+    ResourceAvailabilityService,
     TerminalService,
   ],
 })

apps/agent-app/src/common/constants/terminal.constant.ts

@@ -1,12 +1,22 @@
 import { existsSync } from "node:fs";
+import {
+  SHELL_PATHS,
+  TERMINAL_COLOR_TERM,
+  TERMINAL_TERM_TYPE,
+} from "@shared/common";
 
-export const DEFAULT_TERMINAL_COLS = 80;
-export const DEFAULT_TERMINAL_ROWS = 24;
+export {
+  DEFAULT_TERMINAL_COLS,
+  DEFAULT_TERMINAL_ROWS,
+  TERMINAL_TERM_TYPE,
+} from "@shared/common";
 
-export const TERMINAL_SHELL = existsSync("/bin/bash") ? "/bin/bash" : "/bin/sh";
+export const TERMINAL_SHELL = existsSync(SHELL_PATHS.BASH)
+  ? SHELL_PATHS.BASH
+  : SHELL_PATHS.SH;
 
 export const TERMINAL_ENV = {
   ...process.env,
-  TERM: "xterm-256color",
-  COLORTERM: "truecolor",
+  TERM: TERMINAL_TERM_TYPE,
+  COLORTERM: TERMINAL_COLOR_TERM,
 } as NodeJS.ProcessEnv;

apps/agent-app/src/container/container.service.ts

@@ -50,89 +50,97 @@ export class ContainerService {
     sessionId: string,
     containerId: string,
   ): Promise<string | null> {
-    const trimmedId = containerId.trim();
-    if (!trimmedId) {
-      return "Missing containerId";
-    }
+    try {
+      const trimmedId = containerId.trim();
+      if (!trimmedId) {
+        return "Missing containerId";
+      }
 
-    if (this.logSessions.has(sessionId)) {
-      this.stopLogStream(sessionId);
-    }
+      if (this.logSessions.has(sessionId)) {
+        this.stopLogStream(sessionId);
+      }
 
-    const inspectResult = await this.execCapture(
-      "docker",
-      ["inspect", "-f", "{{.Id}}", trimmedId],
-      CONTAINER_ACTION_TIMEOUT_MS,
-    );
+      const inspectResult = await this.execCapture(
+        "docker",
+        ["inspect", "-f", "{{.Id}}", trimmedId],
+        CONTAINER_ACTION_TIMEOUT_MS,
+      );
 
-    if (inspectResult.exitCode !== 0) {
-      const inspectDetail =
-        inspectResult.stderr.trim() ||
-        inspectResult.stdout.trim() ||
-        `Container '${trimmedId}' not found`;
-      return this.classifyDockerError(inspectDetail);
-    }
+      if (inspectResult.exitCode !== 0) {
+        const inspectDetail =
+          inspectResult.stderr.trim() ||
+          inspectResult.stdout.trim() ||
+          `Container '${trimmedId}' not found`;
+        return this.classifyDockerError(inspectDetail);
+      }
 
-    const resolvedId =
-      inspectResult.stdout.trim().replace(/^sha256:/, "") || trimmedId;
-    const logsTarget =
-      resolvedId.length >= 12 ? resolvedId.slice(0, 12) : trimmedId;
+      const resolvedId =
+        inspectResult.stdout.trim().replace(/^sha256:/, "") || trimmedId;
+      const logsTarget =
+        resolvedId.length >= 12 ? resolvedId.slice(0, 12) : trimmedId;
 
-    const args = CONTAINER_LOGS_COMMAND(logsTarget);
-    this.logger.log(
-      `[CONTAINER_LOGS] starting docker ${args.join(" ")} sessionId=${sessionId}`,
-    );
+      const args = CONTAINER_LOGS_COMMAND(logsTarget);
+      this.logger.log(
+        `[CONTAINER_LOGS] starting docker ${args.join(" ")} sessionId=${sessionId}`,
+      );
 
-    const child = spawn("docker", args, { cwd: process.cwd() });
-    const session: ContainerLogSession = {
-      sessionId,
-      containerId: resolvedId,
-      child,
-      stopping: false,
-      stderr: "",
-    };
+      const child = spawn("docker", args, { cwd: process.cwd() });
+      const session: ContainerLogSession = {
+        sessionId,
+        containerId: resolvedId,
+        child,
+        stopping: false,
+        stderr: "",
+      };
 
-    child.on("error", (err) => {
-      const message = this.classifyDockerError(err.message);
-      this.logger.error(
-        `[CONTAINER_LOGS] failed to start docker logs sessionId=${sessionId}: ${message}`,
-      );
-      this.cleanupLogSession(sessionId, message);
-    });
+      child.on("error", (err) => {
+        const message = this.classifyDockerError(err.message);
+        this.logger.error(
+          `[CONTAINER_LOGS] failed to start docker logs sessionId=${sessionId}: ${message}`,
+        );
+        this.cleanupLogSession(sessionId, message);
+      });
 
-    child.stdout.on("data", (chunk: Buffer | string) => {
-      this.dataHandler?.(sessionId, String(chunk));
-    });
+      child.stdout.on("data", (chunk: Buffer | string) => {
+        this.dataHandler?.(sessionId, String(chunk));
+      });
 
-    child.stderr.on("data", (chunk: Buffer | string) => {
-      const text = String(chunk);
-      session.stderr += text;
-      this.dataHandler?.(sessionId, text);
-    });
+      child.stderr.on("data", (chunk: Buffer | string) => {
+        const text = String(chunk);
+        session.stderr += text;
+        this.dataHandler?.(sessionId, text);
+      });
 
-    child.on("close", (code) => {
-      const activeSession = this.logSessions.get(sessionId);
-      if (!activeSession) {
-        return;
-      }
+      child.on("close", (code) => {
+        const activeSession = this.logSessions.get(sessionId);
+        if (!activeSession) {
+          return;
+        }
 
-      this.logSessions.delete(sessionId);
+        this.logSessions.delete(sessionId);
 
-      if (!activeSession.stopping && code !== 0 && code !== null) {
-        const detail =
-          activeSession.stderr.trim() || `docker logs exited with code ${code}`;
-        this.errorHandler?.(sessionId, this.classifyDockerError(detail));
-      }
+        if (!activeSession.stopping && code !== 0 && code !== null) {
+          const detail =
+            activeSession.stderr.trim() ||
+            `docker logs exited with code ${code}`;
+          this.errorHandler?.(sessionId, this.classifyDockerError(detail));
+        }
 
-      this.closeHandler?.(sessionId);
-      this.logger.log(
-        `[CONTAINER_LOGS] stream closed sessionId=${sessionId} exitCode=${code ?? "null"} stopping=${activeSession.stopping}`,
-      );
-    });
+        this.closeHandler?.(sessionId);
+        this.logger.log(
+          `[CONTAINER_LOGS] stream closed sessionId=${sessionId} exitCode=${code ?? "null"} stopping=${activeSession.stopping}`,
+        );
+      });
 
-    this.logSessions.set(sessionId, session);
+      this.logSessions.set(sessionId, session);
 
-    return null;
+      return null;
+    } catch (error) {
+      this.logger.error(
+        `[CONTAINER_LOGS] start log stream failed sessionId=${sessionId}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      throw error;
+    }
   }
 
   /**
@@ -519,6 +527,7 @@ export class ContainerService {
       });
       child.on("error", (err) => {
         stderr += `Failed to start process: ${err.message}`;
+        finish(1);
       });
       child.on("close", (code) => {
         finish(code ?? 1);