[Feature] Add synchronous socket shell execution to daemon and agent (#45)

* Added synchronous socket connection on the agent's side

* Moved all configuration parameters into

* Now removing temp script dir after command exec

* Updated shell_exec_sync comm method on agent

* Added  basic socket.io comms for saas connections

* Added launch.json to agent because of vscode issues

* Added authentication to socket.io and now sending pid on  event

Author: ubarilan

agent/.vscode/launch.json

@@ -0,0 +1,11 @@
+{
+    "configurations": [
+        {
+            "type": "node-terminal",
+            "name": "Run Script: dev",
+            "request": "launch",
+            "command": "npm run dev",
+            "cwd": "${workspaceFolder}"
+        }
+    ]
+}

agent/package-lock.json

@@ -24,6 +24,7 @@
     "dependencies": {
         "dotenv": "^10.0.0",
         "log4js": "^6.4.1",
+        "mktemp": "^1.0.0",
         "node-fetch": "^2.6.7",
         "node-pty": "^0.10.1",
         "passwd-linux": "^2.0.0",

agent/package.json

@@ -38,8 +38,12 @@ interface possibleArgs {
     password?: string;
     errorReport?: CommandErrorReport | ErrorReport;
     lines?: string | null;
-    status?: 'success' | 'error';
+    status?: 'success' | 'error' | 'running';
     ticket?: TicketOptions;
+    script?: string;
+    output?: string;
+    outputType?: 'stdout' | 'stderr';
+    exitCode?: number;
 }
 
 export class InvalidMessageError extends Error {

agent/src/lib/typing/MessageData.ts

@@ -122,4 +122,5 @@ export function checkIfSocketClosed(socket: WebSocket): boolean {
     );
 }
 
-export const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export const delay = (ms: number) =>
+    new Promise((resolve) => setTimeout(resolve, ms));

agent/src/lib/utils.ts

@@ -1,11 +1,13 @@
-import { ExecException } from 'child_process';
+import { exec, ExecException } from 'child_process';
 import Agent from '../Agent';
 import { CommandErrorReport, ErrorReport } from '../lib/typing/types';
 import { MessageDataResponse } from '../lib/typing/MessageData';
 import { Task } from '../lib/typing/Task';
 import { execAsync, getLastLines } from '../lib/utils';
 import { ActualExecException, ExecReportError } from '../lib/typing/errors';
 import Ticket from '../lib/typing/Ticket';
+import { chmodSync, mkdtempSync, writeFileSync } from 'fs';
+import { rm } from 'fs/promises';
 
 export default class MessageRouting {
     [key: string]: (agent: Agent, task: Task) => Promise<void>;
@@ -139,4 +141,103 @@ export default class MessageRouting {
 
         agent.sendData(clientCommand);
     }
+
+    public static async shell_exec_sync(
+        agent: Agent,
+        task: Task
+    ): Promise<void> {
+        const script: string = task.data.args.script;
+        try {
+            const tmpDir = mkdtempSync('cw-', { encoding: 'utf-8' });
+            const tmpScriptPath = `${tmpDir}/script.sh`;
+            writeFileSync(tmpScriptPath, script, {
+                encoding: 'utf-8',
+                flag: 'w',
+            });
+            chmodSync(tmpScriptPath, 0o755);
+
+            const shell = exec(`/bin/bash ${tmpScriptPath}`);
+
+            shell.stdout.on('data', (data) => {
+                const clientCommand: MessageDataResponse =
+                    new MessageDataResponse({
+                        taskid: task.id,
+                        action: 'shell_exec_sync',
+                        args: {
+                            output: String(data),
+                            outputType: 'stdout',
+                        },
+                    });
+
+                agent.sendData(clientCommand);
+            });
+
+            shell.stderr.on('data', (data) => {
+                const clientCommand: MessageDataResponse =
+                    new MessageDataResponse({
+                        taskid: task.id,
+                        action: 'shell_exec_sync',
+                        args: {
+                            output: String(data),
+                            outputType: 'stderr',
+                        },
+                    });
+
+                agent.sendData(clientCommand);
+
+                shell.kill('SIGKILL');
+            });
+
+            shell.on('exit', (code: number) => {
+                const clientCommand: MessageDataResponse =
+                    new MessageDataResponse({
+                        taskid: task.id,
+                        action: 'shell_exec_sync',
+                        args: {
+                            status: code === 0 ? 'success' : 'error',
+                            exitCode: code,
+                        },
+                    });
+
+                agent.sendData(clientCommand);
+                agent.logger.info(
+                    `Finished executing script with id: ${task.id}`
+                );
+            });
+
+            // TODO: Handle timeout
+
+            agent.logger.info(`Executed script with task id: ${task.id}`);
+            rm(tmpDir, { recursive: true, force: true }).catch(() => {
+                agent.logger.error('Could not delete temporary exec directory');
+            });
+            const clientCommand: MessageDataResponse = new MessageDataResponse({
+                taskid: task.id,
+                action: 'shell_exec_sync',
+                args: {
+                    status: 'running',
+                },
+            });
+
+            agent.sendData(clientCommand);
+        } catch (e) {
+            agent.logger.error(
+                `Failed executing script with task id: ${task.id}, with error: ${e}`
+            );
+
+            const clientCommand: MessageDataResponse = new MessageDataResponse({
+                taskid: task.id,
+                action: 'shell_exec_sync',
+                args: {
+                    status: 'error',
+                    errorReport: {
+                        message: e.message,
+                        stack: e.stack,
+                    },
+                },
+            });
+
+            agent.sendData(clientCommand);
+        }
+    }
 }