termux-app

1
package com.termux.shared.shell.command;
2

3
import android.content.Intent;
4
import android.net.Uri;
5

6
import androidx.annotation.NonNull;
7
import androidx.annotation.Nullable;
8

9
import com.termux.shared.data.IntentUtils;
10
import com.termux.shared.shell.command.result.ResultConfig;
11
import com.termux.shared.shell.command.result.ResultData;
12
import com.termux.shared.errors.Error;
13
import com.termux.shared.logger.Logger;
14
import com.termux.shared.markdown.MarkdownUtils;
15
import com.termux.shared.data.DataUtils;
16
import com.termux.shared.shell.command.runner.app.AppShell;
17
import com.termux.terminal.TerminalSession;
18

19
import java.util.Collections;
20
import java.util.List;
21

22
public class ExecutionCommand {
23

24
    /*
25
    The {@link ExecutionState#SUCCESS} and {@link ExecutionState#FAILED} is defined based on
26
    successful execution of command without any internal errors or exceptions being raised.
27
    The shell command {@link #exitCode} being non-zero **does not** mean that execution command failed.
28
    Only the {@link #errCode} being non-zero means that execution command failed from the Termux app
29
    perspective.
30
    */
31

32
    /** The {@link Enum} that defines {@link ExecutionCommand} state. */
33
    public enum ExecutionState {
34

35
        PRE_EXECUTION("Pre-Execution", 0),
36
        EXECUTING("Executing", 1),
37
        EXECUTED("Executed", 2),
38
        SUCCESS("Success", 3),
39
        FAILED("Failed", 4);
40

41
        private final String name;
42
        private final int value;
43

44
        ExecutionState(final String name, final int value) {
45
            this.name = name;
46
            this.value = value;
47
        }
48

49
        public String getName() {
50
            return name;
51
        }
52

53
        public int getValue() {
54
            return value;
55
        }
56

57

58
    }
59

60
    public enum Runner {
61

62
        /** Run command in {@link TerminalSession}. */
63
        TERMINAL_SESSION("terminal-session"),
64

65
        /** Run command in {@link AppShell}. */
66
        APP_SHELL("app-shell");
67

68
        ///** Run command in {@link AdbShell}. */
69
        //ADB_SHELL("adb-shell"),
70

71
        ///** Run command in {@link RootShell}. */
72
        //ROOT_SHELL("root-shell");
73

74
        private final String name;
75

76
        Runner(final String name) {
77
            this.name = name;
78
        }
79

80
        public String getName() {
81
            return name;
82
        }
83

84
        public boolean equalsRunner(String runner) {
85
            return runner != null && runner.equals(this.name);
86
        }
87

88
        /** Get {@link Runner} for {@code name} if found, otherwise {@code null}. */
89
        @Nullable
90
        public static Runner runnerOf(String name) {
91
            for (Runner v : Runner.values()) {
92
                if (v.name.equals(name)) {
93
                    return v;
94
                }
95
            }
96
            return null;
97
        }
98

99
        /** Get {@link Runner} for {@code name} if found, otherwise {@code def}. */
100
        @NonNull
101
        public static Runner runnerOf(@Nullable String name, @NonNull Runner def) {
102
            Runner runner = runnerOf(name);
103
            return runner != null ? runner : def;
104
        }
105

106
    }
107

108
    public enum ShellCreateMode {
109

110
        /** Always create {@link TerminalSession}. */
111
        ALWAYS("always"),
112

113
        /** Create shell only if no shell with {@link #shellName} found. */
114
        NO_SHELL_WITH_NAME("no-shell-with-name");
115

116
        private final String mode;
117

118
        ShellCreateMode(final String mode) {
119
            this.mode = mode;
120
        }
121

122
        public String getMode() {
123
            return mode;
124
        }
125

126
        public boolean equalsMode(String sessionCreateMode) {
127
            return sessionCreateMode != null && sessionCreateMode.equals(this.mode);
128
        }
129

130
        /** Get {@link ShellCreateMode} for {@code mode} if found, otherwise {@code null}. */
131
        @Nullable
132
        public static ShellCreateMode modeOf(String mode) {
133
            for (ShellCreateMode v : ShellCreateMode.values()) {
134
                if (v.mode.equals(mode)) {
135
                    return v;
136
                }
137
            }
138
            return null;
139
        }
140

141
    }
142

143
    /** The optional unique id for the {@link ExecutionCommand}. This should equal -1 if execution
144
     * command is not going to be managed by a shell manager. */
145
    public Integer id;
146

147
    /** The process id of command. */
148
    public int mPid = -1;
149

150
    /** The current state of the {@link ExecutionCommand}. */
151
    private ExecutionState currentState = ExecutionState.PRE_EXECUTION;
152
    /** The previous state of the {@link ExecutionCommand}. */
153
    private ExecutionState previousState = ExecutionState.PRE_EXECUTION;
154

155

156
    /** The executable for the {@link ExecutionCommand}. */
157
    public String executable;
158
    /** The executable Uri for the {@link ExecutionCommand}. */
159
    public Uri executableUri;
160
    /** The executable arguments array for the {@link ExecutionCommand}. */
161
    public String[] arguments;
162
    /** The stdin string for the {@link ExecutionCommand}. */
163
    public String stdin;
164
    /** The current working directory for the {@link ExecutionCommand}. */
165
    public String workingDirectory;
166

167

168
    /** The terminal transcript rows for the {@link ExecutionCommand}. */
169
    public Integer terminalTranscriptRows;
170

171

172
    /** The {@link Runner} for the {@link ExecutionCommand}. */
173
    public String runner;
174

175
    /** If the {@link ExecutionCommand} is meant to start a failsafe terminal session. */
176
    public boolean isFailsafe;
177

178
    /**
179
     * The {@link ExecutionCommand} custom log level for background {@link AppShell}
180
     * commands. By default, @link com.termux.shared.shell.StreamGobbler} only logs stdout and
181
     * stderr if {@link Logger} `CURRENT_LOG_LEVEL` is >= {@link Logger#LOG_LEVEL_VERBOSE} and
182
     * {@link AppShell} only logs stdin if `CURRENT_LOG_LEVEL` is >=
183
     * {@link Logger#LOG_LEVEL_DEBUG}.
184
     */
185
    public Integer backgroundCustomLogLevel;
186

187

188
    /** The session action of {@link Runner#TERMINAL_SESSION} commands. */
189
    public String sessionAction;
190

191

192
    /** The shell name of commands. */
193
    public String shellName;
194

195
    /** The {@link ShellCreateMode} of commands. */
196
    public String shellCreateMode;
197

198
    /** Whether to set {@link ExecutionCommand} shell environment. */
199
    public boolean setShellCommandShellEnvironment;
200

201

202

203

204
    /** The command label for the {@link ExecutionCommand}. */
205
    public String commandLabel;
206
    /** The markdown text for the command description for the {@link ExecutionCommand}. */
207
    public String commandDescription;
208
    /** The markdown text for the help of command for the {@link ExecutionCommand}. This can be used
209
     * to provide useful info to the user if an internal error is raised. */
210
    public String commandHelp;
211

212

213
    /** Defines the markdown text for the help of the Termux plugin API that was used to start the
214
     * {@link ExecutionCommand}. This can be used to provide useful info to the user if an internal
215
     * error is raised. */
216
    public String pluginAPIHelp;
217

218

219
    /** Defines the {@link Intent} received which started the command. */
220
    public Intent commandIntent;
221

222
    /** Defines if {@link ExecutionCommand} was started because of an external plugin request
223
     * like with an intent or from within Termux app itself. */
224
    public boolean isPluginExecutionCommand;
225

226
    /** Defines the {@link ResultConfig} for the {@link ExecutionCommand} containing information
227
     * on how to handle the result. */
228
    public final ResultConfig resultConfig = new ResultConfig();
229

230
    /** Defines the {@link ResultData} for the {@link ExecutionCommand} containing information
231
     * of the result. */
232
    public final ResultData resultData = new ResultData();
233

234

235
    /** Defines if processing results already called for this {@link ExecutionCommand}. */
236
    public boolean processingResultsAlreadyCalled;
237

238
    private static final String LOG_TAG = "ExecutionCommand";
239

240

241
    public ExecutionCommand() {
242
    }
243

244
    public ExecutionCommand(Integer id) {
245
        this.id = id;
246
    }
247

248
    public ExecutionCommand(Integer id, String executable, String[] arguments, String stdin, String workingDirectory, String runner, boolean isFailsafe) {
249
        this.id = id;
250
        this.executable = executable;
251
        this.arguments = arguments;
252
        this.stdin = stdin;
253
        this.workingDirectory = workingDirectory;
254
        this.runner = runner;
255
        this.isFailsafe = isFailsafe;
256
    }
257

258

259
    public boolean isPluginExecutionCommandWithPendingResult() {
260
        return isPluginExecutionCommand && resultConfig.isCommandWithPendingResult();
261
    }
262

263

264
    public synchronized boolean setState(ExecutionState newState) {
265
        // The state transition cannot go back or change if already at {@link ExecutionState#SUCCESS}
266
        if (newState.getValue() < currentState.getValue() || currentState == ExecutionState.SUCCESS) {
267
            Logger.logError(LOG_TAG, "Invalid "+ getCommandIdAndLabelLogString() + " state transition from \"" + currentState.getName() + "\" to " +  "\"" + newState.getName() + "\"");
268
            return false;
269
        }
270

271
        // The {@link ExecutionState#FAILED} can be set again, like to add more errors, but we don't update
272
        // {@link #previousState} with the {@link #currentState} value if its at {@link ExecutionState#FAILED} to
273
        // preserve the last valid state
274
        if (currentState != ExecutionState.FAILED)
275
            previousState = currentState;
276

277
        currentState = newState;
278
        return  true;
279
    }
280

281
    public synchronized boolean hasExecuted() {
282
        return currentState.getValue() >= ExecutionState.EXECUTED.getValue();
283
    }
284

285
    public synchronized boolean isExecuting() {
286
        return currentState == ExecutionState.EXECUTING;
287
    }
288

289
    public synchronized boolean isSuccessful() {
290
        return currentState == ExecutionState.SUCCESS;
291
    }
292

293

294
    public synchronized boolean setStateFailed(@NonNull Error error) {
295
        return setStateFailed(error.getType(), error.getCode(), error.getMessage(), null);
296
    }
297

298
    public synchronized boolean setStateFailed(@NonNull Error error, Throwable throwable) {
299
        return setStateFailed(error.getType(), error.getCode(), error.getMessage(), Collections.singletonList(throwable));
300
    }
301
    public synchronized boolean setStateFailed(@NonNull Error error, List<Throwable> throwablesList) {
302
        return setStateFailed(error.getType(), error.getCode(), error.getMessage(), throwablesList);
303
    }
304

305
    public synchronized boolean setStateFailed(int code, String message) {
306
        return setStateFailed(null, code, message, null);
307
    }
308

309
    public synchronized boolean setStateFailed(int code, String message, Throwable throwable) {
310
        return setStateFailed(null, code, message, Collections.singletonList(throwable));
311
    }
312

313
    public synchronized boolean setStateFailed(int code, String message, List<Throwable> throwablesList) {
314
        return setStateFailed(null, code, message, throwablesList);
315
    }
316
    public synchronized boolean setStateFailed(String type, int code, String message, List<Throwable> throwablesList) {
317
        if (!this.resultData.setStateFailed(type, code, message, throwablesList)) {
318
            Logger.logWarn(LOG_TAG, "setStateFailed for "  + getCommandIdAndLabelLogString() + " resultData encountered an error.");
319
        }
320

321
        return setState(ExecutionState.FAILED);
322
    }
323

324
    public synchronized boolean shouldNotProcessResults() {
325
        if (processingResultsAlreadyCalled) {
326
            return true;
327
        } else {
328
            processingResultsAlreadyCalled = true;
329
            return false;
330
        }
331
    }
332

333
    public synchronized boolean isStateFailed() {
334
        if (currentState != ExecutionState.FAILED)
335
            return false;
336

337
        if (!resultData.isStateFailed()) {
338
            Logger.logWarn(LOG_TAG, "The "  + getCommandIdAndLabelLogString() + " has an invalid errCode value set in errors list while having ExecutionState.FAILED state.\n" + resultData.errorsList);
339
            return false;
340
        } else {
341
            return true;
342
        }
343
    }
344

345

346
    @NonNull
347
    @Override
348
    public String toString() {
349
        if (!hasExecuted())
350
            return getExecutionInputLogString(this, true, true);
351
        else {
352
            return getExecutionOutputLogString(this, true, true, true);
353
        }
354
    }
355

356
    /**
357
     * Get a log friendly {@link String} for {@link ExecutionCommand} execution input parameters.
358
     *
359
     * @param executionCommand The {@link ExecutionCommand} to convert.
360
     * @param ignoreNull Set to {@code true} if non-critical {@code null} values are to be ignored.
361
     * @param logStdin Set to {@code true} if {@link #stdin} should be logged.
362
     * @return Returns the log friendly {@link String}.
363
     */
364
    public static String getExecutionInputLogString(final ExecutionCommand executionCommand, boolean ignoreNull, boolean logStdin) {
365
        if (executionCommand == null) return "null";
366

367
        StringBuilder logString = new StringBuilder();
368

369
        logString.append(executionCommand.getCommandIdAndLabelLogString()).append(":");
370

371
        if (executionCommand.mPid != -1)
372
            logString.append("\n").append(executionCommand.getPidLogString());
373

374
        if (executionCommand.previousState != ExecutionState.PRE_EXECUTION)
375
            logString.append("\n").append(executionCommand.getPreviousStateLogString());
376
        logString.append("\n").append(executionCommand.getCurrentStateLogString());
377

378
        logString.append("\n").append(executionCommand.getExecutableLogString());
379
        logString.append("\n").append(executionCommand.getArgumentsLogString());
380
        logString.append("\n").append(executionCommand.getWorkingDirectoryLogString());
381
        logString.append("\n").append(executionCommand.getRunnerLogString());
382
        logString.append("\n").append(executionCommand.getIsFailsafeLogString());
383

384
        if (Runner.APP_SHELL.equalsRunner(executionCommand.runner)) {
385
            if (logStdin && (!ignoreNull || !DataUtils.isNullOrEmpty(executionCommand.stdin)))
386
                logString.append("\n").append(executionCommand.getStdinLogString());
387

388
            if (!ignoreNull || executionCommand.backgroundCustomLogLevel != null)
389
                logString.append("\n").append(executionCommand.getBackgroundCustomLogLevelLogString());
390
        }
391

392
        if (!ignoreNull || executionCommand.sessionAction != null)
393
            logString.append("\n").append(executionCommand.getSessionActionLogString());
394

395
        if (!ignoreNull || executionCommand.shellName != null) {
396
            logString.append("\n").append(executionCommand.getShellNameLogString());
397
        }
398

399
        if (!ignoreNull || executionCommand.shellCreateMode != null) {
400
            logString.append("\n").append(executionCommand.getShellCreateModeLogString());
401
        }
402

403
        logString.append("\n").append(executionCommand.getSetRunnerShellEnvironmentLogString());
404

405
        if (!ignoreNull || executionCommand.commandIntent != null)
406
            logString.append("\n").append(executionCommand.getCommandIntentLogString());
407

408
        logString.append("\n").append(executionCommand.getIsPluginExecutionCommandLogString());
409
        if (executionCommand.isPluginExecutionCommand)
410
            logString.append("\n").append(ResultConfig.getResultConfigLogString(executionCommand.resultConfig, ignoreNull));
411

412
        return logString.toString();
413
    }
414

415
    /**
416
     * Get a log friendly {@link String} for {@link ExecutionCommand} execution output parameters.
417
     *
418
     * @param executionCommand The {@link ExecutionCommand} to convert.
419
     * @param ignoreNull Set to {@code true} if non-critical {@code null} values are to be ignored.
420
     * @param logResultData Set to {@code true} if {@link #resultData} should be logged.
421
     * @param logStdoutAndStderr Set to {@code true} if {@link ResultData#stdout} and {@link ResultData#stderr} should be logged.
422
     * @return Returns the log friendly {@link String}.
423
     */
424
    public static String getExecutionOutputLogString(final ExecutionCommand executionCommand, boolean ignoreNull, boolean logResultData, boolean logStdoutAndStderr) {
425
        if (executionCommand == null) return "null";
426

427
        StringBuilder logString = new StringBuilder();
428

429
        logString.append(executionCommand.getCommandIdAndLabelLogString()).append(":");
430

431
        logString.append("\n").append(executionCommand.getPreviousStateLogString());
432
        logString.append("\n").append(executionCommand.getCurrentStateLogString());
433

434
        if (logResultData)
435
            logString.append("\n").append(ResultData.getResultDataLogString(executionCommand.resultData, logStdoutAndStderr));
436

437
        return logString.toString();
438
    }
439

440
    /**
441
     * Get a log friendly {@link String} for {@link ExecutionCommand} with more details.
442
     *
443
     * @param executionCommand The {@link ExecutionCommand} to convert.
444
     * @return Returns the log friendly {@link String}.
445
     */
446
    public static String getDetailedLogString(final ExecutionCommand executionCommand) {
447
        if (executionCommand == null) return "null";
448

449
        StringBuilder logString = new StringBuilder();
450

451
        logString.append(getExecutionInputLogString(executionCommand, false, true));
452
        logString.append(getExecutionOutputLogString(executionCommand, false, true, true));
453

454
        logString.append("\n").append(executionCommand.getCommandDescriptionLogString());
455
        logString.append("\n").append(executionCommand.getCommandHelpLogString());
456
        logString.append("\n").append(executionCommand.getPluginAPIHelpLogString());
457

458
        return logString.toString();
459
    }
460

461
    /**
462
     * Get a markdown {@link String} for {@link ExecutionCommand}.
463
     *
464
     * @param executionCommand The {@link ExecutionCommand} to convert.
465
     * @return Returns the markdown {@link String}.
466
     */
467
    public static String getExecutionCommandMarkdownString(final ExecutionCommand executionCommand) {
468
        if (executionCommand == null) return "null";
469

470
        if (executionCommand.commandLabel == null) executionCommand.commandLabel = "Execution Command";
471

472
        StringBuilder markdownString = new StringBuilder();
473

474
        markdownString.append("## ").append(executionCommand.commandLabel).append("\n");
475

476
        if (executionCommand.mPid != -1)
477
            markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Pid", executionCommand.mPid, "-"));
478

479
        markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Previous State", executionCommand.previousState.getName(), "-"));
480
        markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Current State", executionCommand.currentState.getName(), "-"));
481

482
        markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Executable", executionCommand.executable, "-"));
483
        markdownString.append("\n").append(getArgumentsMarkdownString("Arguments", executionCommand.arguments));
484
        markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Working Directory", executionCommand.workingDirectory, "-"));
485
        markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Runner", executionCommand.runner, "-"));
486
        markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("isFailsafe", executionCommand.isFailsafe, "-"));
487

488
        if (Runner.APP_SHELL.equalsRunner(executionCommand.runner)) {
489
            if (!DataUtils.isNullOrEmpty(executionCommand.stdin))
490
                markdownString.append("\n").append(MarkdownUtils.getMultiLineMarkdownStringEntry("Stdin", executionCommand.stdin, "-"));
491
            if (executionCommand.backgroundCustomLogLevel != null)
492
                markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Background Custom Log Level", executionCommand.backgroundCustomLogLevel, "-"));
493
        }
494

495
        markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Session Action", executionCommand.sessionAction, "-"));
496

497
        markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Shell Name", executionCommand.shellName, "-"));
498
        markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Shell Create Mode", executionCommand.shellCreateMode, "-"));
499
        markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Set Shell Command Shell Environment", executionCommand.setShellCommandShellEnvironment, "-"));
500

501
        markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("isPluginExecutionCommand", executionCommand.isPluginExecutionCommand, "-"));
502

503
        markdownString.append("\n\n").append(ResultConfig.getResultConfigMarkdownString(executionCommand.resultConfig));
504

505
        markdownString.append("\n\n").append(ResultData.getResultDataMarkdownString(executionCommand.resultData));
506

507
        if (executionCommand.commandDescription != null || executionCommand.commandHelp != null) {
508
            if (executionCommand.commandDescription != null)
509
                markdownString.append("\n\n### Command Description\n\n").append(executionCommand.commandDescription).append("\n");
510
            if (executionCommand.commandHelp != null)
511
                markdownString.append("\n\n### Command Help\n\n").append(executionCommand.commandHelp).append("\n");
512
            markdownString.append("\n##\n");
513
        }
514

515
        if (executionCommand.pluginAPIHelp != null) {
516
            markdownString.append("\n\n### Plugin API Help\n\n").append(executionCommand.pluginAPIHelp);
517
            markdownString.append("\n##\n");
518
        }
519

520
        return markdownString.toString();
521
    }
522

523

524
    public String getIdLogString() {
525
        if (id != null)
526
            return "(" + id + ") ";
527
        else
528
            return "";
529
    }
530

531
    public String getPidLogString() {
532
        return "Pid: `" + mPid + "`";
533
    }
534

535
    public String getCurrentStateLogString() {
536
        return "Current State: `" + currentState.getName() + "`";
537
    }
538

539
    public String getPreviousStateLogString() {
540
        return "Previous State: `" + previousState.getName() + "`";
541
    }
542

543
    public String getCommandLabelLogString() {
544
        if (commandLabel != null && !commandLabel.isEmpty())
545
            return commandLabel;
546
        else
547
            return "Execution Command";
548
    }
549

550
    public String getCommandIdAndLabelLogString() {
551
        return getIdLogString() + getCommandLabelLogString();
552
    }
553

554
    public String getExecutableLogString() {
555
        return "Executable: `" + executable + "`";
556
    }
557

558
    public String getArgumentsLogString() {
559
        return getArgumentsLogString("Arguments", arguments);
560
    }
561

562
    public String getWorkingDirectoryLogString() {
563
        return "Working Directory: `" + workingDirectory + "`";
564
    }
565

566
    public String getRunnerLogString() {
567
        return Logger.getSingleLineLogStringEntry("Runner", runner, "-");
568
    }
569

570
    public String getIsFailsafeLogString() {
571
        return "isFailsafe: `" + isFailsafe + "`";
572
    }
573

574
    public String getStdinLogString() {
575
        if (DataUtils.isNullOrEmpty(stdin))
576
            return "Stdin: -";
577
        else
578
            return Logger.getMultiLineLogStringEntry("Stdin", stdin, "-");
579
    }
580

581
    public String getBackgroundCustomLogLevelLogString() {
582
        return "Background Custom Log Level: `" + backgroundCustomLogLevel + "`";
583
    }
584

585
    public String getSessionActionLogString() {
586
        return Logger.getSingleLineLogStringEntry("Session Action", sessionAction, "-");
587
    }
588

589
    public String getShellNameLogString() {
590
        return Logger.getSingleLineLogStringEntry("Shell Name", shellName, "-");
591
    }
592

593
    public String getShellCreateModeLogString() {
594
        return Logger.getSingleLineLogStringEntry("Shell Create Mode", shellCreateMode, "-");
595
    }
596

597
    public String getSetRunnerShellEnvironmentLogString() {
598
        return "Set Shell Command Shell Environment: `" + setShellCommandShellEnvironment + "`";
599
    }
600

601
    public String getCommandDescriptionLogString() {
602
        return Logger.getSingleLineLogStringEntry("Command Description", commandDescription, "-");
603
    }
604

605
    public String getCommandHelpLogString() {
606
        return Logger.getSingleLineLogStringEntry("Command Help", commandHelp, "-");
607
    }
608

609
    public String getPluginAPIHelpLogString() {
610
        return Logger.getSingleLineLogStringEntry("Plugin API Help", pluginAPIHelp, "-");
611
    }
612

613
    public String getCommandIntentLogString() {
614
        if (commandIntent == null)
615
            return "Command Intent: -";
616
        else
617
            return Logger.getMultiLineLogStringEntry("Command Intent", IntentUtils.getIntentString(commandIntent), "-");
618
    }
619

620
    public String getIsPluginExecutionCommandLogString() {
621
        return "isPluginExecutionCommand: `" + isPluginExecutionCommand + "`";
622
    }
623

624

625
    /**
626
     * Get a log friendly {@link String} for {@link List<String>} argumentsArray.
627
     * If argumentsArray are null or of size 0, then `Arguments: -` is returned. Otherwise
628
     * following format is returned:
629
     *
630
     * Arguments:
631
     * ```
632
     * Arg 1: `value`
633
     * Arg 2: 'value`
634
     * ```
635
     *
636
     * @param argumentsArray The {@link String[]} argumentsArray to convert.
637
     * @return Returns the log friendly {@link String}.
638
     */
639
    public static String getArgumentsLogString(String label, final String[] argumentsArray) {
640
        StringBuilder argumentsString = new StringBuilder(label + ":");
641

642
        if (argumentsArray != null && argumentsArray.length != 0) {
643
            argumentsString.append("\n```\n");
644
            for (int i = 0; i != argumentsArray.length; i++) {
645
                argumentsString.append(Logger.getSingleLineLogStringEntry("Arg " + (i + 1),
646
                    DataUtils.getTruncatedCommandOutput(argumentsArray[i], Logger.LOGGER_ENTRY_MAX_SAFE_PAYLOAD / 5, true, false, true),
647
                    "-")).append("\n");
648
            }
649
            argumentsString.append("```");
650
        } else{
651
            argumentsString.append(" -");
652
        }
653

654
        return argumentsString.toString();
655
    }
656

657
    /**
658
     * Get a markdown {@link String} for {@link String[]} argumentsArray.
659
     * If argumentsArray are null or of size 0, then `**Arguments:** -` is returned. Otherwise
660
     * following format is returned:
661
     *
662
     * **Arguments:**
663
     *
664
     * **Arg 1:**
665
     * ```
666
     * value
667
     * ```
668
     * **Arg 2:**
669
     * ```
670
     * value
671
     *```
672
     *
673
     * @param argumentsArray The {@link String[]} argumentsArray to convert.
674
     * @return Returns the markdown {@link String}.
675
     */
676
    public static String getArgumentsMarkdownString(String label, final String[] argumentsArray) {
677
        StringBuilder argumentsString = new StringBuilder("**" + label + ":**");
678

679
        if (argumentsArray != null && argumentsArray.length != 0) {
680
            argumentsString.append("\n");
681
            for (int i = 0; i != argumentsArray.length; i++) {
682
                argumentsString.append(MarkdownUtils.getMultiLineMarkdownStringEntry("Arg " + (i + 1), argumentsArray[i], "-")).append("\n");
683
            }
684
        } else{
685
            argumentsString.append(" -  ");
686
        }
687

688
        return argumentsString.toString();
689
    }
690

691
}
692