[EDR Workflows] Initialize SelectorComponent value in Scripts picker

x-pack/solutions/security/plugins/security_solution/common/endpoint/constants.ts

@@ -86,6 +86,7 @@ export const SUGGESTIONS_INTERNAL_ROUTE = `${BASE_INTERNAL_ENDPOINT_ROUTE}/sugge
 
 /** Base Actions route. Used to get a list of all actions and is root to other action related routes */
 export const BASE_ENDPOINT_ACTION_ROUTE = `${BASE_ENDPOINT_ROUTE}/action`;
+export const BASE_INTERNAL_ENDPOINT_ACTION_ROUTE = `${BASE_INTERNAL_ENDPOINT_ROUTE}/action`;
 
 export const ISOLATE_HOST_ROUTE_V2 = `${BASE_ENDPOINT_ACTION_ROUTE}/isolate`;
 export const UNISOLATE_HOST_ROUTE_V2 = `${BASE_ENDPOINT_ACTION_ROUTE}/unisolate`;
@@ -97,7 +98,9 @@ export const EXECUTE_ROUTE = `${BASE_ENDPOINT_ACTION_ROUTE}/execute`;
 export const UPLOAD_ROUTE = `${BASE_ENDPOINT_ACTION_ROUTE}/upload`;
 export const SCAN_ROUTE = `${BASE_ENDPOINT_ACTION_ROUTE}/scan`;
 export const RUN_SCRIPT_ROUTE = `${BASE_ENDPOINT_ACTION_ROUTE}/run_script`;
-export const CUSTOM_SCRIPTS_ROUTE = `${BASE_ENDPOINT_ACTION_ROUTE}/custom_scripts`;
+
+/** Internal Endpoint Actions Routes */
+export const CUSTOM_SCRIPTS_ROUTE = `${BASE_INTERNAL_ENDPOINT_ACTION_ROUTE}/custom_scripts`;
 
 /** Endpoint Actions Routes */
 export const ACTION_STATUS_ROUTE = `${BASE_ENDPOINT_ROUTE}/action_status`;

x-pack/solutions/security/plugins/security_solution/public/management/components/console/command_handlers/base_command_handler.ts

@@ -0,0 +1,78 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import type { ParsedCommandInterface } from '../service/types';
+import type { ArgSelectorState, EnteredCommand } from '../components/console_state/types';
+
+/**
+ * Base interface for command-specific handlers that define how different commands
+ * should behave in terms of argument parsing, state management, and text reconstruction.
+ */
+export interface CommandHandler {
+  /** The name of the command this handler supports */
+  readonly name: string;
+
+  /**
+   * Returns the list of argument names that should use empty strings for bare flags
+   * instead of boolean true. These are typically selector arguments that can have values.
+   */
+  getEmptyStringArguments(): string[];
+
+  /**
+   * Handle command text reconstruction when selector values change.
+   * Returns the complete command text including all arguments with proper formatting.
+   */
+  reconstructCommandText?(parsedInput: ParsedCommandInterface): {
+    leftOfCursorText?: string;
+    rightOfCursorText?: string;
+    parsedInput: ParsedCommandInterface;
+  };
+
+  /**
+   * Handle any additional state synchronization between parsed input and entered command.
+   * This is called after parsing to ensure consistency between different state representations.
+   */
+  syncState?(parsedInput: ParsedCommandInterface, enteredCommand: EnteredCommand): void;
+
+  /**
+   * Calculate replacement length for text deduplication when selector values change.
+   * Used to determine how much text to replace when updating command arguments.
+   */
+  calculateReplacementLength?(args: {
+    argChrLength: number;
+    argState?: ArgSelectorState;
+    selectorValue: string;
+    input: string;
+    startSearchIndexForNextArg: number;
+    charAfterArgName: string;
+  }): number;
+}
+
+/**
+ * Base class providing common functionality that most command handlers can extend.
+ */
+export abstract class BaseCommandHandler implements CommandHandler {
+  abstract readonly name: string;
+
+  // Upload uses boolean flags (bare flags = true), not empty strings
+  // File selectors work with standard selector patterns only
+  getEmptyStringArguments(): string[] {
+    return [];
+  }
+
+  reconstructCommandText(parsedInput: ParsedCommandInterface): {
+    leftOfCursorText?: string;
+    rightOfCursorText?: string;
+    parsedInput: ParsedCommandInterface;
+  } {
+    return {
+      parsedInput,
+    };
+  }
+
+  syncState(parsedInput: ParsedCommandInterface, enteredCommand: EnteredCommand): void {}
+}

x-pack/solutions/security/plugins/security_solution/public/management/components/console/command_handlers/command_registry.test.ts

@@ -0,0 +1,111 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { CommandRegistry } from './command_registry';
+import { RunscriptCommandHandler } from './runscript_handler';
+import { BaseCommandHandler } from './base_command_handler';
+import type { CommandHandler } from './base_command_handler';
+import type { EnteredCommand } from '../components/console_state/types';
+import type { ParsedCommandInterface } from '../service/types';
+
+describe('CommandRegistry', () => {
+  let registry: CommandRegistry;
+
+  beforeEach(() => {
+    registry = new CommandRegistry();
+  });
+
+  describe('register', () => {
+    it('registers a command handler and delegates methods', () => {
+      const handler = new RunscriptCommandHandler();
+      registry.register(handler);
+      expect(registry.getEmptyStringArguments('runscript')).toEqual(['ScriptName', 'CloudFile']);
+    });
+
+    it('registers multiple command handlers and delegates to each', () => {
+      const runscriptHandler = new RunscriptCommandHandler();
+      const mockHandler = new (class extends BaseCommandHandler {
+        readonly name = 'other';
+      })();
+      registry.register(runscriptHandler);
+      registry.register(mockHandler);
+      expect(registry.getEmptyStringArguments('runscript')).toEqual(['ScriptName', 'CloudFile']);
+      expect(registry.getEmptyStringArguments('other')).toEqual([]);
+    });
+  });
+
+  describe('getEmptyStringArguments', () => {
+    it('returns [] for unregistered commands', () => {
+      expect(registry.getEmptyStringArguments('unknown')).toEqual([]);
+      expect(registry.getEmptyStringArguments('upload')).toEqual([]);
+    });
+
+    it('returns correct empty string arguments for registered commands', () => {
+      registry.register(new RunscriptCommandHandler());
+      expect(registry.getEmptyStringArguments('runscript')).toEqual(['ScriptName', 'CloudFile']);
+      expect(registry.getEmptyStringArguments('upload')).toEqual([]);
+    });
+
+    it('handles upload command correctly without handler', () => {
+      // Upload command uses default boolean flag behavior, not empty string arguments
+      const emptyStringArgs = registry.getEmptyStringArguments('upload');
+      expect(emptyStringArgs).toEqual([]);
+      expect(emptyStringArgs.includes('file')).toBe(false);
+    });
+  });
+
+  describe('delegation to registered handlers', () => {
+    let mockHandler: CommandHandler;
+    beforeEach(() => {
+      mockHandler = {
+        name: 'mock',
+        getEmptyStringArguments: jest.fn().mockReturnValue([]),
+        reconstructCommandText: jest.fn().mockReturnValue('mock command'),
+        syncState: jest.fn(),
+      };
+    });
+
+    it('calls reconstructCommandText on registered handler', () => {
+      registry.register(mockHandler);
+      const parsedInput = {
+        name: 'mock',
+        args: {},
+        hasArg: jest.fn(),
+      } as unknown as ParsedCommandInterface;
+      const result = registry.reconstructCommandText(parsedInput);
+      expect(result).toBe('mock command');
+      expect(mockHandler.reconstructCommandText).toHaveBeenCalledWith(parsedInput);
+    });
+
+    it('calls syncState on registered handler', () => {
+      registry.register(mockHandler);
+      const parsedInput = {
+        name: 'mock',
+        args: {},
+        hasArg: jest.fn(),
+      } as unknown as ParsedCommandInterface;
+      const enteredCommand = {} as EnteredCommand;
+      registry.syncState(parsedInput, enteredCommand);
+      expect(mockHandler.syncState).toHaveBeenCalledWith(parsedInput, enteredCommand);
+    });
+  });
+
+  describe('fallback/default behavior for unregistered commands', () => {
+    it('returns default values and does not throw for unregistered commands', () => {
+      const parsedInput = {
+        name: 'unknown',
+        args: {},
+        hasArg: jest.fn(),
+      } as unknown as ParsedCommandInterface;
+      const enteredCommand = {} as EnteredCommand;
+      // Should not throw and should do nothing for void methods
+      expect(() => registry.syncState(parsedInput, enteredCommand)).not.toThrow();
+      // Should return default object for reconstructCommandText
+      expect(registry.reconstructCommandText(parsedInput)).toEqual({ parsedInput });
+    });
+  });
+});

x-pack/solutions/security/plugins/security_solution/public/management/components/console/command_handlers/command_registry.ts

@@ -0,0 +1,85 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import type { CommandHandler } from './base_command_handler';
+import type { ParsedCommandInterface } from '../service/types';
+import type { ArgSelectorState, EnteredCommand } from '../components/console_state/types';
+
+/**
+ * Registry for managing command-specific handlers. This centralizes all command-specific
+ * logic and eliminates the need for scattered if statements throughout the codebase.
+ */
+export class CommandRegistry {
+  private handlers = new Map<string, CommandHandler>();
+
+  /**
+   * Register a command handler for a specific command name.
+   */
+  register(handler: CommandHandler): void {
+    this.handlers.set(handler.name, handler);
+  }
+
+  /**
+   * Get the list of arguments that should use empty strings for bare flags
+   * instead of boolean true for the given command.
+   */
+  getEmptyStringArguments(commandName: string): string[] {
+    const handler = this.handlers.get(commandName);
+    return handler?.getEmptyStringArguments() ?? [];
+  }
+
+  /**
+   * Reconstruct command text when selector values change.
+   */
+  reconstructCommandText(parsedInput: ParsedCommandInterface): {
+    leftOfCursorText?: string;
+    rightOfCursorText?: string;
+    parsedInput: ParsedCommandInterface;
+  } {
+    const handler = this.handlers.get(parsedInput.name);
+    return (
+      handler?.reconstructCommandText?.(parsedInput) ?? {
+        parsedInput,
+      }
+    );
+  }
+
+  /**
+   * Sync state between parsed input and entered command.
+   */
+  syncState(parsedInput: ParsedCommandInterface, enteredCommand: EnteredCommand): void {
+    const handler = this.handlers.get(parsedInput.name);
+    if (handler?.syncState) {
+      handler.syncState(parsedInput, enteredCommand);
+    }
+  }
+
+  /**
+   * Calculate replacement length for deduplication for the given command.
+   */
+  calculateReplacementLength(
+    commandName: string,
+    args: {
+      argChrLength: number;
+      argState?: ArgSelectorState;
+      selectorValue: string;
+      input: string;
+      startSearchIndexForNextArg: number;
+      charAfterArgName: string;
+    }
+  ): number {
+    const handler = this.handlers.get(commandName);
+    if (handler && typeof handler.calculateReplacementLength === 'function') {
+      return handler.calculateReplacementLength(args);
+    }
+    // Default: just replace argument name (no deduplication logic)
+    return args.argChrLength;
+  }
+}
+
+// Create and export a singleton instance
+export const commandRegistry = new CommandRegistry();

x-pack/solutions/security/plugins/security_solution/public/management/components/console/command_handlers/index.ts

@@ -0,0 +1,21 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+export { BaseCommandHandler } from './base_command_handler';
+export type { CommandHandler } from './base_command_handler';
+export { CommandRegistry, commandRegistry } from './command_registry';
+export { RunscriptCommandHandler } from './runscript_handler';
+export { UploadCommandHandler } from './upload_handler';
+
+// Initialize the command registry with all available handlers
+import { commandRegistry } from './command_registry';
+import { RunscriptCommandHandler } from './runscript_handler';
+import { UploadCommandHandler } from './upload_handler';
+
+// Register all command handlers
+commandRegistry.register(new RunscriptCommandHandler());
+commandRegistry.register(new UploadCommandHandler());