seatalk-bot 0.0.0-alpha1

package/index.js

@@ -0,0 +1,2373 @@
+// index.js
+// A basic framework for a SeaTalk Bot, handling configuration,
+// webhook event parsing, command dispatching, and message sending.
+//
+// This implementation focuses on the core logic of receiving and processing
+// events and commands. Note that actual network requests (like sending
+// messages or running a webhook server) are represented conceptually or
+// with stubs and simulations due to the constraint of using only
+// standard JavaScript built-ins. Signature verification is also simulated.
+// In a real Node.js application, you would use modules like 'http',
+// 'https', 'crypto', and potentially 'events' from the Node.js standard
+// library or external libraries like 'node-fetch', 'express', etc.
+
+/**
+ * Custom error class for configuration issues.
+ */
+class InvalidConfigurationError extends Error {
+    /**
+     * Creates an instance of InvalidConfigurationError.
+     * @param {string} message - The error message.
+     */
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidConfigurationError';
+        // Capture stack trace in V8 environments
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InvalidConfigurationError);
+        }
+    }
+}
+
+/**
+ * Custom error class for message parsing issues.
+ */
+class MessageParsingError extends Error {
+    /**
+     * Creates an instance of MessageParsingError.
+     * @param {string} message - The error message.
+     * @param {*} [originalError] - The original error if wrapping another exception.
+     */
+    constructor(message, originalError) {
+        super(message);
+        this.name = 'MessageParsingError';
+        this.originalError = originalError;
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, MessageParsingError);
+        }
+    }
+}
+
+/**
+ * Custom error class for issues during command registration or execution.
+ */
+class CommandExecutionError extends Error {
+    /**
+     * Creates an instance of CommandExecutionError.
+     * @param {string} message - The error message.
+     * @param {*} [originalError] - The original error if wrapping another exception.
+     */
+    constructor(message, originalError) {
+        super(message);
+        this.name = 'CommandExecutionError';
+        this.originalError = originalError;
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, CommandExecutionError);
+        }
+    }
+}
+
+/**
+ * Custom error class for issues related to API interactions (conceptual in this version).
+ */
+class ApiError extends Error {
+    /**
+     * Creates an instance of ApiError.
+     * @param {string} message - The error message.
+     * @param {number} [statusCode] - The HTTP status code if applicable (conceptual).
+     * @param {*} [details] - Additional details about the error.
+     */
+    constructor(message, statusCode, details) {
+        super(message);
+        this.name = 'ApiError';
+        this.statusCode = statusCode;
+        this.details = details;
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ApiError);
+        }
+    }
+}
+
+// --- Utility Functions ---
+
+/**
+ * Checks if a value is a non-empty string after trimming whitespace.
+ * @param {*} value - The value to check.
+ * @returns {boolean} True if the value is a non-empty string, false otherwise.
+ */
+function isValidString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+
+/**
+ * Checks if a value is a non-negative integer.
+ * @param {*} value - The value to check.
+ * @returns {boolean} True if the value is a non-negative integer, false otherwise.
+ */
+function isValidInteger(value) {
+    return Number.isInteger(value) && value >= 0;
+}
+
+/**
+ * Checks if a value is an array with at least one element.
+ * @param {*} value - The value to check.
+ * @returns {boolean} True if the value is a non-empty array, false otherwise.
+ */
+function isValidArray(value) {
+    return Array.isArray(value) && value.length > 0;
+}
+
+/**
+ * Checks if a value is a plain object (non-null, non-array, typeof 'object').
+ * @param {*} value - The value to check.
+ * @returns {boolean} True if the value is a non-null object and not an array, false otherwise.
+ */
+function isValidObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Generates a timestamp in seconds.
+ * Useful for signature verification and message timestamps.
+ * @returns {number} Current time in seconds since the Unix epoch.
+ */
+function getCurrentTimestampInSeconds() {
+    return Math.floor(Date.now() / 1000);
+}
+
+/**
+ * Simulates signature verification for webhook requests.
+ * In a real scenario, this would use HMAC-SHA256 with the app secret
+ * and compare against the 'X-Signature' header.
+ * Due to standard library constraint (no Node.js 'crypto'), this is a placeholder simulation.
+ * A real implementation MUST use cryptographic hashing.
+ * @param {string} rawBody - The raw request body string.
+ * @param {string} signatureHeader - The value of the 'X-Signature' header.
+ * @param {string} timestampHeader - The value of the 'X-Timestamp' header.
+ * @param {string} appSecret - The bot's app secret.
+ * @returns {boolean} True if the signature is valid (simulated), false otherwise.
+ */
+function simulateSignatureVerification(rawBody, signatureHeader, timestampHeader, appSecret) {
+    // --- Placeholder for actual HMAC-SHA256 Signature Verification ---
+    // In a real scenario, this would look like:
+    // const crypto = require('crypto'); // Needs Node.js 'crypto'
+    // const hmac = crypto.createHmac('sha256', appSecret);
+    // hmac.update(timestampHeader + rawBody);
+    // const expectedSignature = hmac.digest('hex');
+    // return expectedSignature === signatureHeader;
+    // --- End Placeholder ---
+
+    if (!isValidString(rawBody) || !isValidString(signatureHeader) || !isValidString(timestampHeader) || !isValidString(appSecret)) {
+        console.warn('simulateSignatureVerification: Invalid input provided.');
+        return false; // Invalid input means verification fails
+    }
+
+    const providedSignature = signatureHeader.trim();
+    const providedTimestamp = parseInt(timestampHeader, 10);
+
+    if (isNaN(providedTimestamp)) {
+         console.warn('simulateSignatureVerification: Invalid timestamp format.');
+         return false; // Invalid timestamp format means verification fails
+    }
+
+    // Simulate timestamp freshness check
+    const currentTimestamp = getCurrentTimestampInSeconds();
+    const timestampTolerance = 300; // Allow for 5 minutes difference
+
+    if (Math.abs(currentTimestamp - providedTimestamp) > timestampTolerance) {
+        console.warn(`simulateSignatureVerification: Timestamp skew too large. Current: ${currentTimestamp}, Provided: ${providedTimestamp}`);
+        // In a real scenario, this would fail verification.
+        // For this simulation, we'll allow it to pass the timestamp check
+        // so we can focus on the 'signature' part of the simulation.
+        // In a real bot, `return false;` would likely be here.
+    }
+
+    // Simulate signature check: A very basic check to make the code structure look plausible
+    // without actual hashing. This is NOT secure.
+    // The simulation expects the signature header to start with 'valid_signature_for_'
+    // followed by the first 8 characters of the app secret.
+    const expectedPrefix = 'valid_signature_for_';
+    const expectedSignaturePart = appSecret.substring(0, 8);
+
+    const isSignatureMatchSimulated = providedSignature.startsWith(expectedPrefix + expectedSignaturePart);
+
+    if (!isSignatureMatchSimulated) {
+         console.warn(`simulateSignatureVerification: Signature mismatch simulated. Expected prefix: "${expectedPrefix + expectedSignaturePart}", Provided starts with: "${providedSignature.substring(0, expectedPrefix.length + expectedSignaturePart.length)}"`);
+    }
+
+    // In a real scenario, both timestamp and signature must be valid.
+    // Here, we return only the result of the simulated signature match.
+    return isSignatureMatchSimulated;
+}
+
+/**
+ * Parses a string message to identify if it's a command, and extracts command name and arguments.
+ * Assumes commands start with '/' followed by the command name, then space-separated arguments.
+ * @param {string} messageText - The message text to parse.
+ * @returns {{command: string|null, args: string[]|null}} An object with `command` (lowercase name without '/') and `args` (array of strings), or `{ command: null, args: null }` if not a command.
+ */
+function parseCommand(messageText) {
+    if (!isValidString(messageText) || !messageText.startsWith('/')) {
+        return { command: null, args: null };
+    }
+
+    // Remove the leading slash and split the rest by one or more whitespace characters
+    const parts = messageText.substring(1).trim().split(/\s+/);
+
+    // If parts[0] is empty after trim (e.g., message was just '/'), it's not a valid command
+    if (parts.length === 0 || parts[0].length === 0) {
+        return { command: null, args: null };
+    }
+
+    // The first part is the command name, subsequent parts are arguments
+    const command = parts[0].toLowerCase(); // Normalize command name to lowercase
+    const args = parts.slice(1); // Array of argument strings
+
+    console.log(`Parsed command: "${command}" with arguments: [${args.map(arg => `"${arg}"`).join(', ')}]`);
+    return { command, args };
+}
+
+// --- Basic Event Emitter Implementation ---
+// Since Node.js 'events' module is not a standard browser built-in,
+// we implement a basic one here to enable event-driven architecture within the bot.
+
+/**
+ * A basic implementation of an Event Emitter adhering to standard patterns.
+ */
+class EventEmitter {
+    constructor() {
+        /**
+         * @private
+         * @type {Object.<string, Function[]>} Stores listeners for each event name.
+         */
+        this._listeners = {};
+        // Map to track 'once' wrappers to enable proper removal
+        /**
+         * @private
+         * @type {Map<Function, Function>} Maps original 'once' listeners to their wrapper functions.
+         */
+        this._onceWrappers = new Map();
+    }
+
+    /**
+     * Registers an event listener function.
+     * @param {string} eventName - The name of the event to listen for.
+     * @param {Function} listener - The callback function to execute when the event is emitted.
+     * @returns {EventEmitter} Returns the emitter for chaining.
+     */
+    on(eventName, listener) {
+        if (typeof listener !== 'function') {
+            console.error(`EventEmitter: Listener for event "${eventName}" must be a function.`);
+            return this; // Invalid listener provided
+        }
+        if (!isValidString(eventName)) {
+             console.error(`EventEmitter: Event name must be a non-empty string.`);
+             return this; // Invalid event name provided
+        }
+
+        if (!this._listeners[eventName]) {
+            this._listeners[eventName] = [];
+        }
+        // Prevent adding the *exact same function instance* multiple times for the same event
+        // This doesn't prevent adding different functions that do the same thing.
+        if (!this._listeners[eventName].includes(listener)) {
+            this._listeners[eventName].push(listener);
+            // console.debug(`Listener registered for event: "${eventName}"`); // Debugging
+        } else {
+             // console.debug(`Listener already registered for event: "${eventName}"`); // Debugging
+        }
+
+        return this;
+    }
+
+    /**
+     * Registers a one-time event listener. The listener will be invoked only the next time the event is emitted, and then it will be removed.
+     * @param {string} eventName - The name of the event to listen for.
+     * @param {Function} listener - The callback function to execute.
+     * @returns {EventEmitter} Returns the emitter for chaining.
+     */
+    once(eventName, listener) {
+        if (typeof listener !== 'function') {
+             console.error(`EventEmitter: Listener for event "${eventName}" must be a function.`);
+             return this; // Invalid listener provided
+        }
+         if (!isValidString(eventName)) {
+              console.error(`EventEmitter: Event name must be a non-empty string.`);
+              return this; // Invalid event name provided
+         }
+
+        const onceListener = (...args) => {
+            this.off(eventName, onceListener); // Remove this wrapper listener
+            this._onceWrappers.delete(listener); // Remove the mapping
+            listener.apply(this, args); // Call the original listener
+        };
+
+        // Store the mapping from original listener to the wrapper
+        this._onceWrappers.set(listener, onceListener);
+
+        // Register the wrapper listener
+        this.on(eventName, onceListener);
+
+         // console.debug(`'Once' listener registered for event: "${eventName}"`); // Debugging
+        return this;
+    }
+
+    /**
+     * Removes a specific event listener.
+     * @param {string} eventName - The name of the event.
+     * @param {Function} listener - The callback function to remove.
+     * @returns {EventEmitter} Returns the emitter for chaining.
+     */
+    off(eventName, listener) {
+        if (typeof listener !== 'function') {
+             console.error(`EventEmitter: Listener for event "${eventName}" must be a function.`);
+             return this; // Invalid listener provided
+        }
+         if (!isValidString(eventName)) {
+              console.error(`EventEmitter: Event name must be a non-empty string.`);
+              return this; // Invalid event name provided
+         }
+
+        const listeners = this._listeners[eventName];
+        if (!listeners) {
+             // console.debug(`No listeners found for event "${eventName}" to remove.`); // Debugging
+            return this; // No listeners for this event
+        }
+
+        // If the listener is a 'once' listener, find its wrapper to remove
+        const listenerToRemove = this._onceWrappers.get(listener) || listener;
+
+        // Filter out the specific listener function (or its wrapper)
+        const newListeners = listeners.filter(l => l !== listenerToRemove);
+
+        if (newListeners.length < listeners.length) {
+            // Listener was found and removed
+             // console.debug(`Listener removed for event: "${eventName}"`); // Debugging
+             this._listeners[eventName] = newListeners;
+
+             // If it was a 'once' listener, clean up the mapping
+             if (this._onceWrappers.has(listener)) {
+                 this._onceWrappers.delete(listener);
+             }
+        } else {
+            // Listener was not found
+             // console.debug(`Specified listener not found for event: "${eventName}"`); // Debugging
+        }
+
+
+        // Clean up the event entry if no listeners remain
+        if (this._listeners[eventName].length === 0) {
+            delete this._listeners[eventName];
+             // console.debug(`All listeners removed for event: "${eventName}". Event entry deleted.`); // Debugging
+        }
+
+        return this;
+    }
+
+    /**
+     * Removes all listeners for a specific event, or all listeners if no event name is given.
+     * @param {string} [eventName] - The name of the event. If omitted or null/undefined, all listeners for all events are removed.
+     * @returns {EventEmitter} Returns the emitter for chaining.
+     */
+    removeAllListeners(eventName) {
+        if (eventName === undefined || eventName === null) {
+            console.log('Removing all listeners for all events.');
+            this._listeners = {}; // Remove all listeners
+            this._onceWrappers.clear(); // Clear all once mappings
+        } else if (isValidString(eventName)) {
+             console.log(`Removing all listeners for event: "${eventName}".`);
+             if (this._listeners[eventName]) {
+                  // To properly clean up 'once' mappings, we need to iterate
+                 this._listeners[eventName].forEach(listener => {
+                      // Find the original listener associated with this wrapper (if it's a wrapper)
+                      // This requires iterating _onceWrappers, which is inefficient.
+                      // A better 'once' implementation might store the wrapper-to-original mapping.
+                      // For this basic implementation, we'll just remove the event's listeners
+                      // and let the _onceWrappers map potentially retain stale entries
+                      // or clear the whole map if removing all listeners for all events.
+                      // A more robust implementation would be needed for perfect cleanup.
+                 });
+                 delete this._listeners[eventName]; // Remove listeners for a specific event
+             }
+             // Note: Clearing specific event listeners doesn't clean up _onceWrappers efficiently here.
+             // Clearing all listeners with removeAllListeners() (no args) is the way to fully reset.
+        } else {
+             console.error(`EventEmitter: Invalid event name provided to removeAllListeners.`);
+        }
+        return this;
+    }
+
+    /**
+     * Emits an event, calling all registered listeners synchronously in the order they were registered.
+     * Arguments are passed directly to the listener functions.
+     * @param {string} eventName - The name of the event to emit.
+     * @param {...*} args - Arguments to pass to the listener functions.
+     * @returns {boolean} True if the event had listeners, false otherwise.
+     */
+    emit(eventName, ...args) {
+         if (!isValidString(eventName)) {
+              console.error(`EventEmitter: Cannot emit event with invalid name.`);
+              return false; // Cannot emit invalid event name
+         }
+
+        // Get listeners for the event. Clone the array *before* iterating
+        // in case listeners add or remove listeners during emission.
+        const listeners = this._listeners[eventName] ? [...this._listeners[eventName]] : [];
+
+        if (listeners.length === 0) {
+            // console.debug(`No listeners for event "${eventName}".`); // Can be noisy
+            return false; // No listeners
+        }
+
+         // console.debug(`Emitting event "${eventName}" with ${listeners.length} listener(s).`); // Debugging
+
+        // Call each listener
+        for (const listener of listeners) {
+            try {
+                // Call the listener with 'this' context being the emitter itself
+                listener.apply(this, args);
+            } catch (error) {
+                console.error(`EventEmitter: Error in listener for event "${eventName}":`, error);
+                // In many emitter implementations, an 'error' event is emitted here
+                // if a listener throws. We will emit one as well.
+                // Avoid infinite loops if the 'error' listener itself throws.
+                if (eventName !== 'error') {
+                    try {
+                         // Pass the error, the event name, and the arguments that triggered the error
+                         this.emit('error', error, eventName, ...args);
+                    } catch (errInErrorListener) {
+                        console.error(`EventEmitter: Error in 'error' event listener for event "${eventName}":`, errInErrorListener);
+                        // If the error listener fails, just log and stop.
+                    }
+                } else {
+                     // If the 'error' event listener itself throws, we just log.
+                     console.error(`EventEmitter: An 'error' event listener threw an error.`);
+                }
+            }
+        }
+
+        return true; // Event had listeners
+    }
+
+    /**
+     * Returns an array listing the events for which listeners are currently registered.
+     * @returns {string[]} Array of event names.
+     */
+    eventNames() {
+        return Object.keys(this._listeners);
+    }
+
+    /**
+     * Returns the number of listeners for a given event name.
+     * @param {string} eventName - The name of the event.
+     * @returns {number} The number of listeners.
+     */
+    listenerCount(eventName) {
+         if (!isValidString(eventName)) {
+              console.error(`EventEmitter: Invalid event name provided to listenerCount.`);
+              return 0;
+         }
+        const listeners = this._listeners[eventName];
+        return listeners ? listeners.length : 0;
+    }
+
+    /**
+     * Returns a copy of the array of listeners for the specified event.
+     * @param {string} eventName - The name of the event.
+     * @returns {Function[]} Array of listener functions. Returns an empty array if no listeners are registered or eventName is invalid.
+     */
+    listeners(eventName) {
+         if (!isValidString(eventName)) {
+              console.error(`EventEmitter: Invalid event name provided to listeners.`);
+              return [];
+         }
+        const listeners = this._listeners[eventName];
+        return listeners ? [...listeners] : []; // Return a copy to prevent external modification
+    }
+}
+
+
+// --- Configuration Class ---
+
+/**
+ * Manages bot configuration, including loading and validation.
+ */
+class BotConfiguration {
+    /**
+     * Creates a BotConfiguration instance.
+     * Validates required configuration properties upon instantiation.
+     * @param {object} config - The configuration object.
+     * @param {string} config.appId - The SeaTalk App ID.
+     * @param {string} config.appSecret - The SeaTalk App Secret.
+     * @param {string} config.verificationToken - The SeaTalk Verification Token for webhooks.
+     * @param {string} [config.apiBaseUrl='https://openapi.seatalk.io/openapi/v2'] - The base URL for SeaTalk API calls (conceptual).
+     * @param {number} [config.webhookPort=8080] - The port to listen on for webhooks (conceptual). Must be between 1 and 65535.
+     * @throws {InvalidConfigurationError} If the provided configuration is invalid or missing required fields.
+     */
+    constructor(config) {
+        if (!isValidObject(config)) {
+            throw new InvalidConfigurationError('Configuration must be a valid object.');
+        }
+
+        /**
+         * @private
+         * @type {string}
+         */
+        this._appId = '';
+        /**
+         * @private
+         * @type {string}
+         */
+        this._appSecret = '';
+        /**
+         * @private
+         * @type {string}
+         */
+        this._verificationToken = '';
+         /**
+          * @private
+          * @type {string}
+          */
+        this._apiBaseUrl = 'https://openapi.seatalk.io/openapi/v2'; // Default SeaTalk Open API Base URL
+         /**
+          * @private
+          * @type {number}
+          */
+        this._webhookPort = 8080; // Default webhook port
+
+        this._loadConfig(config);
+        this._validateConfig(); // Validate after loading
+
+        console.log('BotConfiguration initialized.');
+    }
+
+    /**
+     * Loads properties from the provided config object into internal state.
+     * Applies default values for optional properties if not provided.
+     * @private
+     * @param {object} config - The raw configuration object.
+     */
+    _loadConfig(config) {
+        // Required fields
+        this._appId = config.appId || '';
+        this._appSecret = config.appSecret || '';
+        this._verificationToken = config.verificationToken || '';
+
+        // Optional configurations with defaults and validation checks
+        if (isValidString(config.apiBaseUrl)) {
+             this._apiBaseUrl = config.apiBaseUrl.trim();
+             // Ensure no trailing slash for consistency, unless it's just the root "/"
+             if (this._apiBaseUrl !== '/' && this._apiBaseUrl.endsWith('/')) {
+                 this._apiBaseUrl = this._apiBaseUrl.slice(0, -1);
+             }
+        } else if (config.apiBaseUrl !== undefined && config.apiBaseUrl !== null && config.apiBaseUrl !== '') {
+             console.warn(`BotConfiguration: Invalid apiBaseUrl value "${config.apiBaseUrl}". Using default ${this._apiBaseUrl}.`);
+        }
+
+
+         if (typeof config.webhookPort === 'number' && Number.isInteger(config.webhookPort) && config.webhookPort > 0 && config.webhookPort <= 65535) {
+            this._webhookPort = config.webhookPort;
+        } else if (config.webhookPort !== undefined) {
+            console.warn(`BotConfiguration: Invalid webhookPort value "${config.webhookPort}". Using default ${this._webhookPort}. Port must be an integer between 1 and 65535.`);
+        }
+
+        // Log loaded status of key configs (careful with sensitive data)
+        console.log(`Config load status: appId(${isValidString(this._appId)}), appSecret(${isValidString(this._appSecret)}), verificationToken(${isValidString(this._verificationToken)}), apiBaseUrl(${this._apiBaseUrl}), webhookPort(${this._webhookPort})`);
+    }
+
+    /**
+     * Validates the loaded configuration properties.
+     * Checks for presence and basic type/format correctness of required fields.
+     * @private
+     * @throws {InvalidConfigurationError} If any required configuration is missing or invalid.
+     */
+    _validateConfig() {
+        if (!isValidString(this._appId)) {
+            throw new InvalidConfigurationError('Configuration missing or invalid required property: appId (must be a non-empty string).');
+        }
+        if (!isValidString(this._appSecret)) {
+            throw new InvalidConfigurationError('Configuration missing or invalid required property: appSecret (must be a non-empty string).');
+        }
+        if (!isValidString(this._verificationToken)) {
+            throw new InvalidConfigurationError('Configuration missing or invalid required property: verificationToken (must be a non-empty string).');
+        }
+        if (!isValidString(this._apiBaseUrl)) {
+             // This check should theoretically be covered by _loadConfig default, but included for robustness
+             throw new InvalidConfigurationError('Configuration property apiBaseUrl is invalid after loading.');
+        }
+         if (!isValidInteger(this._webhookPort) || this._webhookPort <= 0 || this._webhookPort > 65535) {
+              // This check should also be mostly covered by _loadConfig, but double-check final state
+             throw new InvalidConfigurationError('Configuration property webhookPort must be a valid port number (1-65535) integer.');
+         }
+
+         console.log('BotConfiguration validated successfully.');
+    }
+
+    /**
+     * Gets the App ID.
+     * @returns {string} The SeaTalk App ID.
+     */
+    getAppId() {
+        return this._appId;
+    }
+
+    /**
+     * Gets the App Secret.
+     * @returns {string} The SeaTalk App Secret.
+     */
+    getAppSecret() {
+        return this._appSecret;
+    }
+
+    /**
+     * Gets the Verification Token.
+     * @returns {string} The SeaTalk Verification Token.
+     */
+    getVerificationToken() {
+        return this._verificationToken;
+    }
+
+    /**
+     * Gets the API Base URL.
+     * @returns {string} The API Base URL.
+     */
+    getApiBaseUrl() {
+        return this._apiBaseUrl;
+    }
+
+    /**
+     * Gets the Webhook Port.
+     * @returns {number} The webhook port.
+     */
+    getWebhookPort() {
+        return this._webhookPort;
+    }
+
+    /**
+     * Returns a sanitized configuration object suitable for logging or external viewing.
+     * Hides sensitive information like secrets by replacing them with placeholders.
+     * @returns {object} A sanitized configuration object.
+     */
+    getSanitizedConfig() {
+        return {
+            appId: this._appId,
+            appSecret: this._appSecret ? '[HIDDEN]' : '[EMPTY]', // Indicate if secret was provided
+            verificationToken: this._verificationToken ? '[HIDDEN]' : '[EMPTY]', // Indicate if token was provided
+            apiBaseUrl: this._apiBaseUrl,
+            webhookPort: this._webhookPort
+        };
+    }
+}
+
+// --- Message and Event Data Structures ---
+// Classes representing parsed incoming SeaTalk events and messages.
+
+/**
+ * Base class for incoming webhook events.
+ * Provides common fields present in all SeaTalk webhook event types.
+ */
+class SeaTalkEvent {
+    /**
+     * Constructs a base SeaTalkEvent instance.
+     * @param {object} data - Raw event data object from the parsed webhook payload.
+     * @param {string} data.event_type - Type of the event (e.g., 'message', 'callback', 'add_bot').
+     * @param {string} data.token - Verification token from the request payload body.
+     * @param {string} data.timestamp - Timestamp from the request payload body (usually string).
+     * @param {string} data.open_app_id - The app ID the event is for.
+     * @param {string} [data.open_chat_id] - The ID of the chat where the event occurred (if applicable, not all events have this).
+     * @throws {MessageParsingError} If the basic event data structure is invalid.
+     */
+    constructor(data) {
+        if (!isValidObject(data)) {
+            throw new MessageParsingError('Event data must be a valid object.');
+        }
+        if (!isValidString(data.event_type)) {
+             throw new MessageParsingError('Event data missing required "event_type" field.');
+        }
+        if (!isValidString(data.token)) {
+             throw new MessageParsingError('Event data missing required "token" field.');
+        }
+         if (!isValidString(data.timestamp)) {
+              throw new MessageParsingError('Event data missing required "timestamp" field.');
+         }
+         if (!isValidString(data.open_app_id)) {
+              throw new MessageParsingError('Event data missing required "open_app_id" field.');
+         }
+
+
+        /**
+         * The type of the event (e.g., 'message').
+         * @type {string}
+         */
+        this.eventType = data.event_type;
+        /**
+         * The verification token included in the payload.
+         * @type {string}
+         */
+        this.token = data.token;
+        /**
+         * The timestamp of the event (as a string, typically epoch seconds).
+         * @type {string}
+         */
+        this.timestamp = data.timestamp;
+        /**
+         * The open App ID the event was sent to.
+         * @type {string}
+         */
+        this.openAppId = data.open_app_id;
+        /**
+         * The open chat ID associated with the event (if applicable).
+         * @type {string|null}
+         */
+        this.openChatId = data.open_chat_id || null; // Optional field
+
+        // Store raw data for potential inspection or debugging
+        /**
+         * The original raw object payload data for this event.
+         * @type {object}
+         */
+        this.rawData = data;
+
+         console.debug(`Created base SeaTalkEvent (Type: ${this.eventType}, App: ${this.openAppId}, Chat: ${this.openChatId})`);
+    }
+
+    /**
+     * Validates the basic required fields for any event type.
+     * Note: This duplicates checks in the constructor but can be useful for post-instantiation checks.
+     * @returns {boolean} True if basic fields are present and valid strings.
+     */
+    isValid() {
+        return isValidString(this.eventType) &&
+               isValidString(this.token) &&
+               isValidString(this.timestamp) &&
+               isValidString(this.openAppId);
+    }
+}
+
+/**
+ * Represents an incoming message event, inheriting from SeaTalkEvent.
+ * Includes message-specific details like sender, content, chat type, etc.
+ */
+class SeaTalkMessageEvent extends SeaTalkEvent {
+    /**
+     * Constructs a SeaTalkMessageEvent instance.
+     * @param {object} data - Raw message event data from the parsed webhook payload.
+     * @param {object} data.message - The core message payload object.
+     * @param {string} data.message.message_id - Unique message ID.
+     * @param {string} data.message.chat_type - 'group', 'p2p', etc.
+     * @param {string} data.message.open_chat_id - The chat ID. This should match data.open_chat_id.
+     * @param {string} data.message.sender_type - 'user', 'bot', etc.
+     * @param {string} data.message.sender_user_id - User ID of the sender.
+     * @param {string} data.message.message_type - 'text', 'image', etc.
+     * @param {string} data.message.create_time - Message creation timestamp (usually string).
+     * @param {object} data.message.content - Message content depending on type.
+     * @param {object} [data.sender] - Optional sender details object.
+     * @param {string} [data.sender.tenant_user_id] - Tenant-specific user ID from sender details.
+     * // ... other message specific fields as documented by SeaTalk API
+     * @throws {MessageParsingError} If the message data structure is invalid or missing required message fields.
+     */
+    constructor(data) {
+        // Validate base event structure first
+        super(data);
+
+        // Ensure the event type is explicitly 'message'
+        if (this.eventType !== 'message') {
+            // This check should theoretically be done by the parser before calling this constructor,
+            // but included here for robustness.
+            throw new MessageParsingError(`Expected event_type 'message' for SeaTalkMessageEvent, but got '${this.eventType}'`);
+        }
+
+        const message = data.message;
+        if (!isValidObject(message)) {
+            throw new MessageParsingError('Message event data must contain a valid "message" object.');
+        }
+         // Also check required fields within the message object
+         if (!isValidString(message.message_id)) throw new MessageParsingError('Message object missing required "message_id" field.');
+         if (!isValidString(message.chat_type)) throw new MessageParsingError('Message object missing required "chat_type" field.');
+         if (!isValidString(message.open_chat_id)) throw new MessageParsingError('Message object missing required "open_chat_id" field.');
+         if (!isValidString(message.sender_type)) throw new MessageParsingError('Message object missing required "sender_type" field.');
+         if (!isValidString(message.sender_user_id)) throw new MessageParsingError('Message object missing required "sender_user_id" field.');
+         if (!isValidString(message.message_type)) throw new MessageParsingError('Message object missing required "message_type" field.');
+         if (!isValidString(message.create_time)) throw new MessageParsingError('Message object missing required "create_time" field.');
+         if (!isValidObject(message.content)) throw new MessageParsingError('Message object missing required "content" object.');
+
+
+        /**
+         * Unique identifier for the message.
+         * @type {string}
+         */
+        this.messageId = message.message_id;
+        /**
+         * Type of chat: 'group', 'p2p'.
+         * @type {string}
+         */
+        this.chatType = message.chat_type;
+         /**
+          * Type of sender: 'user', 'bot'.
+          * @type {string}
+          */
+        this.senderType = message.sender_type;
+        /**
+         * Unique user ID of the sender.
+         * @type {string}
+         */
+        this.senderUserId = message.sender_user_id;
+         /**
+          * Type of message content: 'text', 'image', 'file', 'card', etc.
+          * @type {string}
+          */
+        this.messageType = message.message_type;
+        /**
+         * Timestamp when the message was created (as a string).
+         * @type {string}
+         */
+        this.createTime = message.create_time; // Keep as string, conversion might be needed later
+
+        /**
+         * The content payload of the message. Structure varies based on `messageType`.
+         * @type {object}
+         */
+        this.content = message.content; // This structure varies by message type
+
+        // Optional fields from the top level data object related to the sender or chat context
+        /**
+         * Tenant-specific user ID from the sender details (if provided).
+         * @type {string|null}
+         */
+        this.tenantUserId = (data.sender && isValidString(data.sender.tenant_user_id)) ? data.sender.tenant_user_id : null;
+        // Add other potential sender/chat/etc. fields from rawData if needed
+
+         console.debug(`Created SeaTalkMessageEvent (ID: ${this.messageId}, Type: ${this.messageType}, From: ${this.senderUserId}, Chat: ${this.openChatId})`);
+    }
+
+    /**
+     * Validates the message event specific fields in addition to base event fields.
+     * Checks for presence and basic type correctness of all properties set in the constructor.
+     * @returns {boolean} True if all message specific fields are present and valid.
+     */
+    isMessageValid() {
+         return this.isValid() && // Validate base event fields
+               isValidString(this.messageId) &&
+               isValidString(this.chatType) &&
+               isValidString(this.senderType) &&
+               isValidString(this.senderUserId) &&
+               isValidString(this.messageType) &&
+               isValidString(this.createTime) &&
+               isValidObject(this.content); // Content must be an object, though its properties depend on type
+    }
+
+    /**
+     * Gets the text content if the message type is 'text'.
+     * Performs basic validation on the content structure for text messages.
+     * @returns {string|null} The text content string or null if not a text message or content is invalid.
+     */
+    getTextContent() {
+        if (this.messageType === 'text' && isValidObject(this.content) && typeof this.content.text === 'string') {
+            return this.content.text;
+        }
+        return null;
+    }
+
+    // Placeholder methods for accessing content of other message types (conceptual)
+    /**
+     * Gets the image content if the message type is 'image'.
+     * Placeholder for retrieving image-specific data structure.
+     * @returns {object|null} The image content object or null if not an image message or content is invalid.
+     */
+    getImageContent() {
+         if (this.messageType === 'image' && isValidObject(this.content)) {
+              // Return structured image data object (e.g., { image_key: '...', caption: '...' })
+              // Validate specific image properties here in a real implementation
+              if (typeof this.content.image_key === 'string') {
+                   return this.content; // Return the content object as is for simplicity in placeholder
+              }
+         }
+         return null;
+    }
+
+    /**
+     * Gets the file content if the message type is 'file'.
+     * Placeholder for retrieving file-specific data structure.
+     * @returns {object|null} The file content object or null if not a file message or content is invalid.
+     */
+    getFileContent() {
+         if (this.messageType === 'file' && isValidObject(this.content)) {
+             // Return structured file data object (e.g., { file_key: '...', file_name: '...', file_size: ... })
+             // Validate specific file properties here in a real implementation
+              if (typeof this.content.file_key === 'string' && typeof this.content.file_name === 'string') {
+                  return this.content; // Return the content object as is for simplicity in placeholder
+              }
+         }
+         return null;
+    }
+
+    // Add more methods for other message types like getCardContent(), etc.
+}
+
+// Add more specific event types like 'SeaTalkCallbackEvent', 'SeaTalkAddBotEvent', etc.
+// based on SeaTalk API documentation, inheriting from SeaTalkEvent.
+// class SeaTalkCallbackEvent extends SeaTalkEvent { /* ... validation and properties ... */ }
+// class SeaTalkAddBotEvent extends SeaTalkEvent { /* ... validation and properties ... */ }
+
+
+// --- Message Parser ---
+
+/**
+ * Handles parsing raw webhook payload (JSON string) into structured SeaTalkEvent objects.
+ * Selects the appropriate event class based on the 'event_type'.
+ */
+class MessageParser {
+    /**
+     * Creates a MessageParser instance.
+     */
+    constructor() {
+        console.log('MessageParser initialized.');
+    }
+
+    /**
+     * Parses a raw JSON string payload from a webhook request body into a specific SeaTalkEvent object.
+     * Dispatches to appropriate constructors based on `event_type`.
+     * @param {string} rawPayload - The raw JSON payload string.
+     * @returns {SeaTalkEvent|SeaTalkMessageEvent|null} A parsed and validated event object. Returns null only if the payload is empty string or whitespace.
+     * @throws {MessageParsingError} If the payload is invalid JSON, missing required top-level fields, or the specific event structure is invalid.
+     */
+    parseWebhookPayload(rawPayload) {
+        // Allow empty or whitespace raw payload to return null without error,
+        // as some webhook systems might send keepalives or invalid empty data.
+        if (!isValidString(rawPayload)) {
+            console.warn('MessageParser: Received empty or invalid raw payload string.');
+            return null;
+        }
+
+        let payloadObject;
+        try {
+            // Attempt to parse the string as JSON
+            payloadObject = JSON.parse(rawPayload);
+             console.debug('Payload parsed as JSON.');
+        } catch (error) {
+            // Catch JSON parsing errors
+            console.error('MessageParser: Failed to parse payload as JSON.', error);
+            throw new MessageParsingError('Failed to parse payload as JSON.', error);
+        }
+
+        // Check if the parsed result is a valid object
+        if (!isValidObject(payloadObject)) {
+             console.error('MessageParser: Parsed payload is not a valid object.');
+             throw new MessageParsingError('Parsed payload is not a valid object.');
+        }
+
+        // Check for the mandatory 'event_type' field at the top level
+        const eventType = payloadObject.event_type;
+        if (!isValidString(eventType)) {
+            console.error('MessageParser: Payload missing required "event_type" field.');
+            throw new MessageParsingError('Payload missing required "event_type" field.');
+        }
+
+        console.log(`MessageParser: Identifying event type "${eventType}".`);
+
+        // Dispatch based on event_type to the appropriate event class constructor
+        try {
+            let event;
+            switch (eventType) {
+                case 'message':
+                    // Construct and validate a Message Event
+                    event = new SeaTalkMessageEvent(payloadObject);
+                    if (!event.isMessageValid()) {
+                         // The constructor throws on critical validation failure,
+                         // but this provides an extra layer or could be used for non-critical warnings.
+                         console.warn('MessageParser: Parsed message event failed detailed validation.', event);
+                         // Depending on strictness, could throw here:
+                         // throw new MessageParsingError('Parsed message event failed detailed validation.');
+                    }
+                    console.log(`MessageParser: Successfully created SeaTalkMessageEvent (ID: ${event.messageId}).`);
+                    return event;
+
+                // Add cases for other event types here:
+                // case 'callback':
+                //    // Validate and return a SeaTalkCallbackEvent
+                //    event = new SeaTalkCallbackEvent(payloadObject);
+                //    if (!event.isValidCallback()) { ... } // Add type-specific validation
+                //    return event;
+
+                // case 'add_bot':
+                //    // Validate and return a SeaTalkAddBotEvent
+                //    return new SeaTalkAddBotEvent(payloadObject);
+
+                default:
+                    // For unhandled or unknown event types, return a generic SeaTalkEvent
+                    // Ensure the basic structure is valid for the generic event.
+                    console.warn(`MessageParser: Received unhandled event type: "${eventType}". Creating generic SeaTalkEvent.`);
+                     event = new SeaTalkEvent(payloadObject); // Base class constructor validates basic fields
+                      if (!event.isValid()) {
+                           // This check should theoretically be covered by the SeaTalkEvent constructor,
+                           // but added here for safety.
+                           console.warn('MessageParser: Parsed generic event failed basic validation.', event);
+                            throw new MessageParsingError(`Parsed generic event of type "${eventType}" is structurally invalid.`);
+                      }
+                     console.log(`MessageParser: Successfully created generic SeaTalkEvent (Type: ${event.eventType}).`);
+                    return event;
+            }
+        } catch (error) {
+            // Catch errors thrown by the event constructors (like missing required fields)
+            console.error(`MessageParser: Error creating event object for type "${eventType}":`, error);
+            // Re-throw the parsing error with context
+            if (error instanceof MessageParsingError) {
+                 throw error;
+            } else {
+                 throw new MessageParsingError(`Failed to instantiate event object for type "${eventType}": ${error.message}`, error);
+            }
+        }
+    }
+}
+
+// --- Command Manager ---
+
+/**
+ * Manages registration and dispatching of command handlers.
+ * A command handler is a function that executes specific logic in response to a command message.
+ */
+class CommandManager {
+    /**
+     * Creates a CommandManager instance.
+     */
+    constructor() {
+        /**
+         * @private
+         * @type {Object.<string, Function>} Stores command handler functions, keyed by the lowercase command name (without the leading '/').
+         */
+        this._commands = {};
+        console.log('CommandManager initialized.');
+    }
+
+    /**
+     * Registers a handler function for a specific command name.
+     * The command name should be provided WITHOUT the leading '/'. It is case-insensitive.
+     * If a handler for the same command name is already registered, it will be overwritten.
+     * @param {string} commandName - The name of the command (e.g., 'help', 'status', 'config'). Must be a non-empty string without '/'.
+     * @param {Function} handler - The function to call when the command is received. This function should accept two arguments: `messageEvent` (the SeaTalkMessageEvent object) and `args` (an array of strings representing command arguments). The handler can be synchronous or asynchronous (return a Promise).
+     * @throws {CommandRegistrationError} If the command name is invalid or the handler is not a function.
+     */
+    registerCommand(commandName, handler) {
+        if (!isValidString(commandName)) {
+            throw new CommandRegistrationError('Command name must be a non-empty string.');
+        }
+        if (commandName.startsWith('/')) {
+             throw new CommandRegistrationError('Command name should not start with "/". Provide the name like "help", not "/help".');
+        }
+        if (typeof handler !== 'function') {
+            throw new CommandRegistrationError(`Handler for command "${commandName}" must be a function.`);
+        }
+
+        const normalizedCommandName = commandName.toLowerCase(); // Store command names lowercase
+
+        if (this._commands[normalizedCommandName]) {
+            console.warn(`Command "${normalizedCommandName}" was already registered. Overwriting handler.`);
+        }
+
+        this._commands[normalizedCommandName] = handler;
+        console.log(`Command "${normalizedCommandName}" registered successfully.`);
+    }
+
+    /**
+     * Checks if a command is registered in the manager.
+     * The input command name can optionally include the leading '/'. It is case-insensitive.
+     * @param {string} commandName - The command name to check (e.g., 'help' or '/help').
+     * @returns {boolean} True if a handler is registered for the given command name, false otherwise.
+     */
+    isCommandRegistered(commandName) {
+         if (!isValidString(commandName)) {
+              return false; // Invalid input is not a registered command
+         }
+         // Normalize the input command name for lookup
+         const name = commandName.startsWith('/') ? commandName.substring(1) : commandName;
+         return typeof this._commands[name.toLowerCase()] === 'function';
+    }
+
+    /**
+     * Dispatches a command to its registered handler function.
+     * This method is called internally by the bot when a message is identified as a command.
+     * It retrieves the handler and executes it with the message event and arguments.
+     * @param {string} commandName - The name of the command to dispatch (WITHOUT the leading '/'). Case-insensitive matching is performed internally.
+     * @param {string[]} args - An array of string arguments for the command.
+     * @param {SeaTalkMessageEvent} messageEvent - The original message event object that triggered the command.
+     * @returns {Promise<void>} A promise that resolves when the handler finishes execution (including async handlers), or rejects if the command is not registered or the handler throws an error.
+     * @throws {CommandExecutionError} If the command is not registered or if the handler execution fails.
+     */
+    async dispatchCommand(commandName, args, messageEvent) {
+        if (!isValidString(commandName)) {
+             throw new CommandExecutionError('Invalid command name provided for dispatch.');
+        }
+         if (!Array.isArray(args)) {
+              // Args should always be an array from parseCommand, but check for safety
+              console.warn(`Command dispatch received non-array args for "${commandName}". Converting.`);
+              args = []; // Default to empty array if invalid
+         }
+        if (!(messageEvent instanceof SeaTalkMessageEvent)) {
+             throw new CommandExecutionError('Provided event is not a valid SeaTalkMessageEvent object for command dispatch.');
+        }
+
+        const normalizedCommandName = commandName.toLowerCase(); // Look up using lowercase name
+        const handler = this._commands[normalizedCommandName];
+
+        if (!handler) {
+            // This scenario should ideally not be reached if dispatch is called after isCommandRegistered check.
+            // It might happen if commands are unregistered dynamically between check and dispatch.
+            console.error(`CommandManager: Attempted to dispatch unregistered command "${normalizedCommandName}".`);
+            throw new CommandExecutionError(`No handler registered for command "${normalizedCommandName}".`);
+        }
+
+        console.log(`CommandManager: Dispatching command "${normalizedCommandName}" for message ID ${messageEvent.messageId} with args: [${args.join(', ')}]`);
+
+        try {
+            // Call the handler function. Use await Promise.resolve() to correctly handle
+            // both synchronous and asynchronous (Promise-returning) handlers.
+            await Promise.resolve(handler(messageEvent, args));
+            console.log(`CommandManager: Command "${normalizedCommandName}" handler finished successfully.`);
+        } catch (error) {
+            // Catch errors thrown by the command handler
+            console.error(`CommandManager: Error executing command "${normalizedCommandName}" handler:`, error);
+            // Wrap and re-throw with context
+            throw new CommandExecutionError(`Error executing command "${normalizedCommandName}".`, error);
+        }
+    }
+
+    /**
+     * Returns a list of all command names that are currently registered.
+     * Names are returned in lowercase without the leading '/'.
+     * @returns {string[]} An array of registered command names. Returns an empty array if no commands are registered.
+     */
+    getRegisteredCommands() {
+        return Object.keys(this._commands);
+    }
+}
+
+// --- SeaTalkBot Core Class ---
+
+/**
+ * The main class for the SeaTalk Bot.
+ * It extends EventEmitter to allow emitting events for bot lifecycle,
+ * incoming messages, commands, and errors.
+ * Orchestrates configuration, webhook event processing, and command dispatching.
+ */
+class SeaTalkBot extends EventEmitter {
+    /**
+     * Creates a SeaTalkBot instance.
+     * Initializes configuration, message parser, and command manager.
+     * Throws InvalidConfigurationError if the provided config is invalid.
+     * @param {object} config - The bot configuration object. See BotConfiguration constructor for required fields.
+     * @throws {InvalidConfigurationError} If the initial configuration is invalid.
+     */
+    constructor(config) {
+        // Initialize the event emitter first
+        super();
+
+        console.log('Initializing SeaTalkBot...');
+
+        try {
+            /**
+             * @private
+             * @type {BotConfiguration} Manages bot configuration settings.
+             */
+            this._config = new BotConfiguration(config);
+        } catch (error) {
+            console.error('SeaTalkBot: Failed to initialize BotConfiguration:', error);
+            // Configuration errors are critical and should prevent bot instantiation
+            throw error; // Re-throw the InvalidConfigurationError
+        }
+
+        /**
+         * @private
+         * @type {MessageParser} Handles parsing raw webhook payloads.
+         */
+        this._messageParser = new MessageParser();
+
+        /**
+         * @private
+         * @type {CommandManager} Manages and dispatches command handlers.
+         */
+        this._commandManager = new CommandManager();
+
+        // Internal state to track if the conceptual server is running
+        /**
+         * @private
+         * @type {boolean} Indicates if the conceptual webhook server is running.
+         */
+        this._isRunning = false;
+
+        console.log('SeaTalkBot initialized successfully.');
+        // Emit an event indicating that the bot instance has been successfully initialized
+         this.emit('initialized');
+         // Emit a 'ready' event, as the bot is now conceptually ready to handle processing requests
+         // Note: In a real app, 'ready' might be emitted *after* the actual HTTP server starts listening.
+         this.emit('ready');
+    }
+
+    /**
+     * Registers a command handler function with the bot's command manager.
+     * This makes the bot respond to messages starting with `/commandName`.
+     * @param {string} commandName - The name of the command (WITHOUT the leading '/'). Case-insensitive.
+     * @param {Function} handler - The function to call when the command is received. It should accept `messageEvent` and `args` as parameters. Can be async.
+     * @throws {CommandRegistrationError} If the command name or handler is invalid during registration.
+     */
+    registerCommand(commandName, handler) {
+        try {
+            this._commandManager.registerCommand(commandName, handler);
+             // Emit an event after successful registration
+             this.emit('command_registered', commandName);
+        } catch (error) {
+            console.error(`SeaTalkBot: Failed to register command "${commandName}":`, error);
+            // Propagate the CommandRegistrationError
+            throw error;
+        }
+    }
+
+     /**
+      * Checks if the bot has a specific command registered by name.
+      * Accepts command names with or without the leading '/'. Case-insensitive.
+      * @param {string} commandName - The name of the command to check (e.g., 'help' or '/help').
+      * @returns {boolean} True if the command is registered, false otherwise.
+      */
+     isCommandRegistered(commandName) {
+          return this._commandManager.isCommandRegistered(commandName);
+     }
+
+     /**
+      * Gets a list of all command names currently registered with the bot.
+      * Names are returned in lowercase without the leading '/'.
+      * @returns {string[]} An array of registered command names.
+      */
+     getRegisteredCommands() {
+         return this._commandManager.getRegisteredCommands();
+     }
+
+    /**
+     * Conceptual method to start a webhook server to receive events from SeaTalk.
+     * In a real application, this would bind to a port and listen for HTTP POST requests.
+     * Due to the standard library constraint, this is a placeholder that simulates the action
+     * and state change, but does not create a real network server.
+     * @fires SeaTalkBot#server_started
+     * @fires SeaTalkBot#error on failure (conceptual)
+     */
+    startWebhookServer() {
+        if (this._isRunning) {
+            console.warn('SeaTalkBot: Conceptual webhook server is already conceptually running.');
+            return;
+        }
+
+        const port = this._config.getWebhookPort();
+        console.log(`SeaTalkBot: Attempting to start conceptual webhook server on port ${port}...`);
+
+        // --- Placeholder for Actual Node.js HTTP Server Creation ---
+        // const http = require('http'); // Requires Node.js 'http' module
+        // try {
+        //     this._server = http.createServer((req, res) => {
+        //         // Read request body and headers, then call this.processWebhookEvent
+        //         let rawBody = '';
+        //         req.on('data', (chunk) => { rawBody += chunk.toString(); });
+        //         req.on('end', () => {
+        //             const signatureHeader = req.headers['x-signature'];
+        //             const timestampHeader = req.headers['x-timestamp'];
+        //             this.processWebhookEvent(rawBody, signatureHeader, timestampHeader)
+        //                 .then(() => {
+        //                      res.statusCode = 200;
+        //                      res.setHeader('Content-Type', 'text/plain');
+        //                      res.end('OK');
+        //                 })
+        //                 .catch((error) => {
+        //                      console.error('Error processing webhook event:', error);
+        //                      res.statusCode = error instanceof InvalidConfigurationError || error instanceof MessageParsingError || error instanceof ApiError && error.statusCode === 401 ? 400 : 500; // Use 400 for client/parsing errors, 401 for auth/sig failures, 500 for internal
+        //                      res.setHeader('Content-Type', 'text/plain');
+        //                      res.end(`Error: ${error.message}`); // Send a basic error message back
+        //                      // Additional error handling/logging can happen in the 'error' event listener
+        //                 });
+        //         });
+        //          req.on('error', (err) => {
+        //               console.error('Error reading incoming request:', err);
+        //               if (!res.headersSent) { // Prevent sending headers if already sent by end() in the catch block
+        //                   res.statusCode = 500;
+        //                   res.setHeader('Content-Type', 'text/plain');
+        //                   res.end('Internal server error');
+        //               }
+        //               // Emit a bot error event
+        //               this.emit('error', new ApiError('Error reading incoming webhook request', 500, err));
+        //           });
+        //     });
+        //
+        //     this._server.listen(port, () => {
+        //         console.log(`SeaTalkBot: Actual webhook server listening on port ${port}`);
+        //         this._isRunning = true;
+        //         this.emit('server_started', port); // Emit event for successful start
+        //     });
+        //
+        //     this._server.on('error', (err) => {
+        //          console.error('SeaTalkBot: Actual webhook server error:', err);
+        //          this._isRunning = false; // Server failed or stopped due to error
+        //          // Emit a bot error event
+        //          this.emit('error', new ApiError(`Webhook server failed: ${err.message}`, null, err));
+        //     });
+        //
+        // } catch (err) {
+        //      console.error('SeaTalkBot: Could not create or start actual HTTP server:', err);
+        //      this._isRunning = false; // Ensure status is false
+        //      // Emit error event if server creation itself failed (unlikely with just listen)
+        //      this.emit('error', new ApiError('Could not create or start webhook server', null, err));
+        // }
+        // --- End Placeholder ---
+
+        // Simulate successful startup after a small delay to mimic asynchronous operations
+        console.log(`SeaTalkBot: Simulating successful conceptual webhook server startup on port ${port}.`);
+        this._isRunning = true;
+        setTimeout(() => {
+            /**
+             * Server started event.
+             * @event SeaTalkBot#server_started
+             * @type {number} The port the server is listening on (conceptual).
+             */
+            this.emit('server_started', port);
+             console.log('SeaTalkBot is now conceptually receiving webhook events.');
+        }, 10); // Use a small timeout to make it async like a real server start
+
+    }
+
+    /**
+     * Conceptual method to stop the webhook server.
+     * Placeholder for real server shutdown logic (e.g., `server.close()`).
+     * @fires SeaTalkBot#server_stopped
+     */
+    stopWebhookServer() {
+        if (!this._isRunning) {
+            console.warn('SeaTalkBot: Conceptual webhook server is not running.');
+            return;
+        }
+
+        console.log('SeaTalkBot: Attempting to stop conceptual webhook server...');
+
+        // --- Placeholder for Actual Node.js HTTP Server Shutdown ---
+        // if (this._server) {
+        //     this._server.close(() => {
+        //         console.log('SeaTalkBot: Actual webhook server stopped.');
+        //         this._isRunning = false;
+        //         this.emit('server_stopped'); // Emit event for successful stop
+        //         this._server = null; // Clean up reference
+        //     });
+        //      this._server.on('error', (err) => {
+        //           console.error('SeaTalkBot: Error during server shutdown:', err);
+        //           // Emit error event if shutdown fails
+        //           this.emit('error', new ApiError('Webhook server shutdown failed', null, err));
+        //      });
+        // } else {
+        //    console.warn('SeaTalkBot: No actual server instance found to stop.');
+        //    this._isRunning = false; // Ensure status is false
+        //    this.emit('server_stopped'); // Still emit event if state was inconsistent
+        // }
+        // --- End Placeholder ---
+
+        // Simulate successful shutdown after a small delay
+        console.log('SeaTalkBot: Simulating successful conceptual webhook server shutdown.');
+        this._isRunning = false;
+        setTimeout(() => {
+             /**
+              * Server stopped event.
+              * @event SeaTalkBot#server_stopped
+              */
+             this.emit('server_stopped');
+             console.log('SeaTalkBot webhook server is conceptually stopped.');
+        }, 10); // Use a small timeout
+    }
+
+    /**
+     * Processes a raw webhook event payload received from SeaTalk.
+     * This is the core method that validates the request, parses the payload,
+     * identifies the event type, and dispatches it to appropriate handlers or command managers.
+     * Intended to be called by your webhook server's request handler.
+     * @param {string} rawBody - The raw request body string received from SeaTalk.
+     * @param {string} signatureHeader - The value of the 'X-Signature' HTTP header.
+     * @param {string} timestampHeader - The value of the 'X-Timestamp' HTTP header.
+     * @returns {Promise<void>} A promise that resolves when processing is complete, or rejects on error. The caller (your server handler) should catch rejections and send appropriate HTTP error responses (e.g., 400, 401, 500).
+     * @fires SeaTalkBot#event
+     * @fires SeaTalkBot#message
+     * @fires SeaTalkBot#command
+     * @fires SeaTalkBot#unregistered_command
+     * @fires SeaTalkBot#event_[eventType] (e.g., event_message, event_callback)
+     * @fires SeaTalkBot#message_[messageType] (e.g., message_text, message_image)
+     * @fires SeaTalkBot#signature_verification_failed
+     * @fires SeaTalkBot#token_verification_failed
+     * @fires SeaTalkBot#parsing_error
+     * @fires SeaTalkBot#validation_failed
+     * @fires SeaTalkBot#error
+     */
+    async processWebhookEvent(rawBody, signatureHeader, timestampHeader) {
+        console.log('SeaTalkBot: Starting processing of incoming webhook event...');
+         // console.debug('Raw Body (first 100 chars):', rawBody ? rawBody.substring(0, 100) + (rawBody.length > 100 ? '...' : '') : '[empty]'); // Log safely
+
+        // 1. Validate Signature (Simulated)
+        const appSecret = this._config.getAppSecret();
+        const isSignatureValid = simulateSignatureVerification(rawBody, signatureHeader, timestampHeader, appSecret);
+
+        if (!isSignatureValid) {
+            console.error('SeaTalkBot: Webhook signature verification failed.');
+             /**
+              * Emitted when the webhook signature verification fails.
+              * @event SeaTalkBot#signature_verification_failed
+              * @type {object} Context containing the raw request details.
+              * @property {string} rawBody - The raw body of the request.
+              * @property {string} signatureHeader - The received X-Signature header.
+              * @property {string} timestampHeader - The received X-Timestamp header.
+              */
+            this.emit('signature_verification_failed', {
+                 rawBody,
+                 signatureHeader,
+                 timestampHeader
+            });
+            // Throw an ApiError with a 401 status code as signature failure implies unauthorized request
+            throw new ApiError('Signature verification failed. Request rejected.', 401);
+        }
+        console.log('SeaTalkBot: Webhook signature verification simulated successfully.');
+
+
+        // 2. Parse Payload
+        let event;
+        try {
+            // Use the message parser to convert raw body to a structured event object
+            event = this._messageParser.parseWebhookPayload(rawBody);
+
+             // If parser returns null (e.g., empty body), we just finish processing without error or event emission
+             if (event === null) {
+                 console.log('SeaTalkBot: Payload parsed as null (likely empty body). Finishing processing.');
+                 return; // Stop processing
+             }
+
+             // Validate verification token received in the payload against the configured one
+             if (event.token !== this._config.getVerificationToken()) {
+                 console.error(`SeaTalkBot: Verification token mismatch. Configured: ${this._config.getVerificationToken()}, Received: ${event.token}`);
+                  /**
+                   * Emitted when the webhook verification token in the payload body does not match the configured token.
+                   * @event SeaTalkBot#token_verification_failed
+                   * @type {object} Context including received/expected tokens and the parsed event.
+                   * @property {string} receivedToken - The token from the payload.
+                   * @property {string} expectedToken - The configured token.
+                   * @property {SeaTalkEvent} event - The parsed event object.
+                   */
+                  this.emit('token_verification_failed', {
+                       receivedToken: event.token,
+                       expectedToken: this._config.getVerificationToken(),
+                       event
+                  });
+                 // Token mismatch implies unauthorized request
+                 throw new ApiError('Verification token mismatch. Request rejected.', 401);
+             }
+             console.log('SeaTalkBot: Verification token matched.');
+
+             // Perform basic validation on the parsed event object
+             if (!event.isValid()) {
+                  console.error('SeaTalkBot: Parsed event object failed basic validation after token check.');
+                  /**
+                   * Emitted when a parsed event object fails basic validation checks.
+                   * @event SeaTalkBot#validation_failed
+                   * @type {SeaTalkEvent} The parsed event object.
+                   */
+                  this.emit('validation_failed', event);
+                  throw new MessageParsingError(`Parsed event object of type "${event.eventType}" is structurally invalid.`);
+             }
+
+
+        } catch (error) {
+            // Catch errors during JSON parsing or event object instantiation/basic validation
+            console.error('SeaTalkBot: Error parsing or validating webhook payload:', error);
+             /**
+              * Emitted when there is an error parsing the raw webhook payload or validating its basic structure.
+              * @event SeaTalkBot#parsing_error
+              * @type {Error} The parsing error.
+              * @property {string} rawBody - The raw body that caused the error.
+              */
+             this.emit('parsing_error', error, rawBody);
+            // Re-throw as MessageParsingError or wrap existing error, use 400 status code
+            if (error instanceof MessageParsingError) {
+                 throw error; // Already a parsing error
+            } else if (error instanceof ApiError && error.statusCode === 401) {
+                 throw error; // Re-throw 401 token error
+            }
+            else {
+                 // Wrap any other unexpected parsing/validation error
+                 throw new MessageParsingError(`Failed to parse or validate event payload: ${error.message}`, error);
+            }
+        }
+
+        // 3. Dispatch Event based on Type
+        console.log(`SeaTalkBot: Dispatching event of type: ${event.eventType}`);
+
+        /**
+         * Emitted for any incoming webhook event after successful parsing and token verification.
+         * @event SeaTalkBot#event
+         * @type {SeaTalkEvent} The parsed event object.
+         */
+        this.emit('event', event);
+
+        /**
+         * Emitted for incoming events, specific to their event type.
+         * The event name will be `event_[eventType]`.
+         * @event SeaTalkBot#event_[eventType]
+         * @type {SeaTalkEvent} The parsed event object.
+         */
+         this.emit(`event_${event.eventType}`, event);
+
+
+        switch (event.eventType) {
+            case 'message':
+                // Handle incoming message events
+                // Ensure it's a valid SeaTalkMessageEvent instance and passes its specific validations
+                if (event instanceof SeaTalkMessageEvent && event.isMessageValid()) {
+                    console.log(`SeaTalkBot: Handling incoming message from ${event.senderUserId} in chat ${event.openChatId}, type ${event.messageType}.`);
+                    /**
+                     * Emitted specifically for incoming message events.
+                     * @event SeaTalkBot#message
+                     * @type {SeaTalkMessageEvent} The parsed message event object.
+                     */
+                    this.emit('message', event);
+
+                    // Emit specific message type event (e.g., 'message_text', 'message_image')
+                     /**
+                      * Emitted for incoming messages, specific to their message type.
+                      * The event name will be `message_[messageType]`.
+                      * @event SeaTalkBot#message_[messageType]
+                      * @type {SeaTalkMessageEvent} The parsed message event object.
+                      */
+                     this.emit(`message_${event.messageType}`, event);
+
+                    // Process message content for commands if it's a text message
+                    if (event.messageType === 'text') {
+                        const messageText = event.getTextContent();
+                        if (messageText !== null) {
+                            const commandInfo = parseCommand(messageText); // Use the utility to parse
+
+                            if (commandInfo.command !== null) {
+                                // It looks like a command (starts with '/')
+                                console.log(`SeaTalkBot: Message identified as potential command: "${commandInfo.command}"`);
+                                if (this._commandManager.isCommandRegistered(commandInfo.command)) {
+                                    console.log(`SeaTalkBot: Command "${commandInfo.command}" is registered. Dispatching.`);
+                                     /**
+                                      * Emitted when a message is identified as a registered command.
+                                      * @event SeaTalkBot#command
+                                      * @type {string} The command name (lowercase, no '/').
+                                      * @type {string[]} The command arguments.
+                                      * @type {SeaTalkMessageEvent} The original message event.
+                                      */
+                                     this.emit('command', commandInfo.command, commandInfo.args, event);
+
+                                    try {
+                                        // Dispatch to the registered command handler. Await the handler's completion.
+                                        await this._commandManager.dispatchCommand(commandInfo.command, commandInfo.args, event);
+                                        console.log(`SeaTalkBot: Command "${commandInfo.command}" dispatched and handled.`);
+                                    } catch (commandError) {
+                                        // Catch errors thrown by the command handler
+                                        console.error(`SeaTalkBot: Error during command "${commandInfo.command}" execution:`, commandError);
+                                        // Emit a bot error event for handler errors
+                                         this.emit('error', new CommandExecutionError(`Error handling command "${commandInfo.command}"`, commandError), { event, commandInfo });
+                                        // Depending on desired behavior, you might re-throw or handle differently
+                                        // Re-throw to potentially signal failure back to the conceptual server handler
+                                        throw new CommandExecutionError(`Error executing command "${commandInfo.command}".`, commandError);
+                                    }
+                                } else {
+                                     // Command syntax used, but command is not registered
+                                     console.warn(`SeaTalkBot: Received unregistered command: "${commandInfo.command}"`);
+                                     /**
+                                      * Emitted when a message starts with '/' but does not match a registered command.
+                                      * @event SeaTalkBot#unregistered_command
+                                      * @type {string} The command name (lowercase, no '/').
+                                      * @type {string[]} The command arguments.
+                                      * @type {SeaTalkMessageEvent} The original message event.
+                                      */
+                                     this.emit('unregistered_command', commandInfo.command, commandInfo.args, event);
+                                     // Optionally, reply to the user that the command is not found
+                                     // This would involve calling sendMessage, which is conceptual here.
+                                     // Example: await this.sendMessage(event.openChatId, `Error: Command "${commandInfo.command}" not found.`);
+                                 }
+                            } else {
+                                // The message is text but not a command (doesn't start with '/')
+                                console.log('SeaTalkBot: Message is text but not a command.');
+                                // You can add logic here to handle non-command text messages,
+                                // e.g., simple keyword responses, AI processing, etc.
+                                // Or let listeners on the 'message' or 'message_text' event handle it.
+                            }
+                        } else {
+                             // messageType was 'text', but getTextContent returned null (content.text missing or invalid)
+                             console.warn('SeaTalkBot: Received text message event with invalid text content structure.');
+                             // Optionally emit a more specific validation failure event
+                             this.emit('validation_failed', event);
+                        }
+                    } else {
+                         // Message type is not 'text'
+                         console.log(`SeaTalkBot: Message type is "${event.messageType}", no command processing needed.`);
+                         // Logic for handling non-text messages goes here or is handled by listeners
+                         // on the specific message type event ('message_image', etc.) or the general 'message' event.
+                    }
+
+                } else {
+                     // The event was type 'message', but the SeaTalkMessageEvent instance failed its detailed validation
+                     console.warn('SeaTalkBot: Received message event failed specific SeaTalkMessageEvent validation.', event);
+                     // Emit a validation failure event specifically for messages
+                     this.emit('validation_failed', event);
+                     // Do not process this invalid message further
+                }
+                break;
+
+            // Add cases for handling other specific SeaTalk event types here:
+            // case 'callback':
+            //     // Handle incoming callback events (e.g., button clicks)
+            //     console.log('SeaTalkBot: Handling incoming callback event...');
+            //     // Ensure it's a valid callback event instance and passes its specific validations
+            //     if (event instanceof SeaTalkCallbackEvent && event.isValidCallback()) {
+            //         this.emit('callback', event); // Emit a specific callback event
+            //         // Add callback handling logic here or in listeners
+            //     } else {
+            //         console.warn('SeaTalkBot: Received callback event failed specific validation.', event);
+            //         this.emit('validation_failed', event);
+            //     }
+            //     break;
+
+            // case 'add_bot':
+            //     // Handle bot added to chat event
+            //     console.log('SeaTalkBot: Handling bot added event...');
+            //      if (event instanceof SeaTalkAddBotEvent && event.isValidAddBot()) {
+            //          this.emit('add_bot', event); // Emit a specific add_bot event
+            //          // Logic like sending a welcome message could go here or in listeners
+            //      } else {
+            //          console.warn('SeaTalkBot: Received add_bot event failed specific validation.', event);
+            //          this.emit('validation_failed', event);
+            //      }
+            //     break;
+
+            default:
+                // For any other event type not explicitly handled above
+                console.log(`SeaTalkBot: Received unhandled specific event type: ${event.eventType}. Generic event already emitted.`);
+                // Additional processing for unhandled types can go here or be handled by listeners
+                // on the general 'event' or specific 'event_[eventType]' events.
+                break;
+        }
+
+        console.log('SeaTalkBot: Webhook event processing finished.');
+    }
+
+    /**
+     * Conceptual method to send a text message to a specific chat ID in SeaTalk.
+     * In a real application, this involves obtaining an access token (if not cached)
+     * and making an HTTP POST request to the SeaTalk Send Message API endpoint.
+     * Due to the standard library constraint, this is a placeholder simulation
+     * that logs the intended action and returns a simulated response.
+     * @param {string} chatId - The open_chat_id of the conversation to send the message to. Must be a non-empty string.
+     * @param {string} text - The text content of the message to send. Must be a non-empty string.
+     * @returns {Promise<object>} A promise resolving with a conceptual API success response object `{ code: 0, message: 'success', data: { ... } }` or rejecting with an `ApiError` on conceptual failure.
+     * @throws {ApiError} If the chat ID or text is invalid, or if the conceptual API call fails.
+     */
+    async sendMessage(chatId, text) {
+        // Basic input validation
+        if (!isValidString(chatId)) {
+            console.error('SeaTalkBot: Cannot send message: Invalid chat ID provided.');
+            throw new ApiError('Cannot send message: Invalid chat ID. Must be a non-empty string.');
+        }
+        if (!isValidString(text)) {
+            console.error('SeaTalkBot: Cannot send message: Text content is empty or invalid.');
+            // Allow empty text if SeaTalk API allows? Usually, text messages must have content.
+            throw new ApiError('Cannot send message: Text content must be a non-empty string.');
+        }
+
+        console.log(`SeaTalkBot: Simulating sending text message to chat "${chatId}" with content: "${text.substring(0, 50) + (text.length > 50 ? '...' : '')}"`);
+
+        const apiEndpoint = `${this._config.getApiBaseUrl()}/message/send`;
+        const payload = {
+            open_chat_id: chatId,
+            message_type: 'text',
+            content: {
+                text: text
+            }
+            // Add other necessary fields based on SeaTalk API for sending messages
+            // e.g., 'msg_uuid' for idempotency, 'user_id' for P2P chat if needed differently
+        };
+
+        // --- Placeholder for Actual HTTP POST request using Node.js http/https or fetch ---
+        // In a real scenario, you would typically:
+        // 1. Call an internal method like `_getAccessToken()` to get a valid token.
+        // 2. Make an HTTP POST request using `fetch` or Node.js `https.request`.
+        // 3. Set headers: `Content-Type: application/json`, `Authorization: Bearer <AccessToken>`.
+        // 4. Send `JSON.stringify(payload)` as the request body.
+        // 5. Handle the API response (check status code, parse JSON body, check SeaTalk API `code` field).
+
+        /*
+        try {
+            const accessToken = await this._getAccessToken(); // Assumes _getAccessToken exists and works
+
+            const response = await fetch(apiEndpoint, { // Requires 'node-fetch' or similar in Node.js context
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${accessToken}` // Use the obtained token
+                },
+                body: JSON.stringify(payload)
+            });
+
+            const responseBody = await response.json(); // Parse the JSON response body
+
+            // Check HTTP status code first
+            if (!response.ok) {
+                console.error(`SeaTalkBot: API HTTP error sending message to ${chatId}: Status ${response.status}`, responseBody);
+                 // Throw an ApiError including the HTTP status and response body details
+                throw new ApiError(`API call failed to send message (HTTP Status: ${response.status})`, response.status, responseBody);
+            }
+
+             // Check SeaTalk API specific code for success
+             if (responseBody.code !== 0) {
+                  console.error(`SeaTalkBot: SeaTalk API error sending message to ${chatId}: Code ${responseBody.code}`, responseBody);
+                  // Throw an ApiError based on SeaTalk's response structure
+                  throw new ApiError(`SeaTalk API returned error code ${responseBody.code} when sending message`, response.status, responseBody); // Include HTTP status even for API code errors
+             }
+
+
+            console.log(`SeaTalkBot: Message sent successfully to ${chatId}. Conceptual response data:`, responseBody.data);
+            return responseBody; // Return the full API success response object
+
+        } catch (error) {
+             // Catch network errors or errors thrown by fetch/request or parsing
+             console.error(`SeaTalkBot: Error during conceptual sendMessage API call to ${apiEndpoint}:`, error);
+             // Re-throw as ApiError if not already, preserving context
+             if (error instanceof ApiError) {
+                 throw error; // Already an ApiError, just re-throw
+             } else {
+                // Wrap general errors (network issues, etc.) in an ApiError
+                throw new ApiError(`Conceptual API call failed to send message: ${error.message}`, null, error);
+             }
+        }
+        */
+        // --- End Placeholder ---
+
+
+        // Simulate a successful API response after a short delay
+        // This promise simulates the asynchronous nature of an HTTP request.
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                console.log('SeaTalkBot: Simulated API call for sendMessage completed.');
+                // Simulate successful response structure according to SeaTalk API docs
+                const simulatedResponse = {
+                    code: 0, // SeaTalk API success code
+                    message: 'success',
+                    data: {
+                         // Example data for a sent message response
+                         message_id: `simulated_msg_${Date.now()}_${Math.random().toString(16).slice(2, 8)}`, // Simulate a unique message ID
+                         open_message_id: `simulated_om_${Date.now()}_${Math.random().toString(16).slice(2, 8)}`,
+                         create_time: String(getCurrentTimestampInSeconds())
+                    }
+                };
+                console.log('SeaTalkBot: Simulating successful message send response:', simulatedResponse);
+                resolve(simulatedResponse); // Resolve the promise with the simulated success response
+
+                // --- Example of how to simulate an API error ---
+                /*
+                const simulatedErrorResponse = {
+                    code: 1001, // Example SeaTalk error code
+                    message: 'Simulated API error: Invalid chat ID',
+                    details: { field: 'open_chat_id', reason: 'not_found' }
+                };
+                console.error('SeaTalkBot: Simulating API call failure:', simulatedErrorResponse);
+                // Reject the promise with an ApiError
+                reject(new ApiError('Simulated SeaTalk API Error sending message', 400, simulatedErrorResponse)); // Use an appropriate conceptual HTTP status code
+                */
+
+            }, 50); // Simulate a small network delay (50 milliseconds)
+        });
+    }
+
+    /**
+     * Conceptual method to obtain an Access Token from the SeaTalk API.
+     * In a real application, this makes an HTTP POST request with App ID and App Secret.
+     * Tokens are typically valid for a limited time and should be cached.
+     * Due to the standard library constraint, this is a placeholder simulation.
+     * @private
+     * @returns {Promise<string>} A promise resolving with the access token string on conceptual success.
+     * @throws {ApiError} If the conceptual API call for the token fails (e.g., invalid credentials simulation).
+     */
+    async _getAccessToken() {
+        console.log('SeaTalkBot: Simulating getting Access Token...');
+
+        const tokenEndpoint = `${this._config.getApiBaseUrl()}/auth/access_token`;
+        const appId = this._config.getAppId();
+        const appSecret = this._config.getAppSecret();
+
+        // Validate that we conceptually have credentials to request a token
+        if (!isValidString(appId) || !isValidString(appSecret)) {
+             console.error('SeaTalkBot: Cannot get access token: App ID or App Secret is missing in configuration.');
+             throw new ApiError('Cannot get access token: Missing required appId or appSecret in configuration.', null, { appId: appId, appSecret: appSecret ? '[PRESENT]' : '[MISSING]' });
+        }
+
+
+        // --- Placeholder for Actual HTTP POST request using fetch or Node.js http/https ---
+        /*
+        try {
+            const response = await fetch(tokenEndpoint, { // Requires 'node-fetch' or similar
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    app_id: appId,
+                    app_secret: appSecret
+                })
+            });
+
+            const responseBody = await response.json();
+
+            // Check HTTP status code
+            if (!response.ok) {
+                 console.error(`SeaTalkBot: API HTTP error getting access token: Status ${response.status}`, responseBody);
+                 throw new ApiError(`API call failed to get access token (HTTP Status: ${response.status})`, response.status, responseBody);
+            }
+
+            // Check SeaTalk API specific code and data structure for the token
+            if (responseBody.code !== 0 || !isValidObject(responseBody.data) || !isValidString(responseBody.data.access_token)) {
+                console.error(`SeaTalkBot: SeaTalk API error getting access token: Code ${responseBody.code}`, responseBody);
+                 throw new ApiError(`SeaTalk API returned error code ${responseBody.code} or invalid data getting access token`, response.status, responseBody);
+            }
+
+            console.log('SeaTalkBot: Access Token obtained successfully.');
+            // In a real implementation, you would cache responseBody.data.access_token
+            // and responseBody.data.expires_in, and manage token refreshing.
+            return responseBody.data.access_token;
+
+        } catch (error) {
+            console.error(`SeaTalkBot: Error during conceptual _getAccessToken API call to ${tokenEndpoint}:`, error);
+            if (error instanceof ApiError) {
+                 throw error;
+            } else {
+                 throw new ApiError(`Conceptual API call failed to get access token: ${error.message}`, null, error);
+            }
+        }
+        */
+        // --- End Placeholder ---
+
+        // Simulate a successful response after a small delay
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                console.log('SeaTalkBot: Simulated API call for Access Token completed.');
+                 // Simulate a successful response structure
+                const simulatedResponse = {
+                    code: 0,
+                    message: 'success',
+                    data: {
+                        access_token: `simulated_token_${Date.now()}_${Math.random().toString(16).slice(2, 8)}`,
+                        expires_in: 7200 // 2 hours validity
+                    }
+                };
+                console.log('SeaTalkBot: Simulating successful Access Token retrieval.');
+                resolve(simulatedResponse.data.access_token); // Resolve with the simulated token string
+
+                // --- Example of how to simulate an API error for token retrieval ---
+                /*
+                 const simulatedErrorResponse = {
+                     code: 10001, // Example auth error code
+                     message: 'Simulated invalid app_secret',
+                     details: {}
+                 };
+                 console.error('SeaTalkBot: Simulating API call failure for token:', simulatedErrorResponse);
+                 reject(new ApiError('Simulated SeaTalk API Error getting token', 401, simulatedErrorResponse)); // Use 401 for auth failures
+                 */
+
+            }, 50); // Simulate a small network delay
+        });
+    }
+
+
+    /**
+     * Gets the current running status of the conceptual webhook server.
+     * @returns {boolean} True if `startWebhookServer` has been called and `stopWebhookServer` has not, false otherwise.
+     */
+    isRunning() {
+        return this._isRunning;
+    }
+
+    /**
+     * Provides access to the bot's configuration, with sensitive details hidden.
+     * @returns {object} A sanitized version of the bot configuration object.
+     */
+    getConfig() {
+        return this._config.getSanitizedConfig();
+    }
+
+    /**
+     * Provides a helper method to structure a basic text message content object.
+     * Useful when constructing payloads for methods like `sendMessage`.
+     * @param {string} text - The text content for the message.
+     * @returns {object|null} A message content object `{ text: string }` or null if the input text is invalid.
+     */
+    createTextContent(text) {
+        if (!isValidString(text)) {
+             console.warn('SeaTalkBot: createTextContent received invalid or empty text.');
+             return null;
+        }
+        return {
+            text: text
+        };
+    }
+
+    // Add more helper methods for creating content objects for other message types
+    // /**
+    //  * Helper to structure a basic card message content object.
+    //  * @param {object} cardData - The data structure for the card according to SeaTalk API.
+    //  * @returns {object|null} A message content object `{ card: object }` or null if cardData is invalid.
+    //  */
+    // createCardContent(cardData) {
+    //     if (!isValidObject(cardData)) {
+    //         console.warn('SeaTalkBot: createCardContent received invalid card data.');
+    //         return null;
+    //     }
+    //     // Basic check: Card data often has a 'config' and 'elements' property
+    //     if (!isValidObject(cardData.config) || !isValidArray(cardData.elements)) {
+    //          console.warn('SeaTalkBot: createCardContent received card data missing config or elements array.');
+    //          // Return null or return the data as is? Let's be strict and return null for invalid structure
+    //          return null;
+    //     }
+    //     return {
+    //         card: cardData
+    //     };
+    // }
+
+    // Add placeholder methods for other potential API interactions (conceptual)
+    // async getUserInfo(userId) { /* ... conceptual API call to /user/get ... */ }
+    // async getChatInfo(chatId) { /* ... conceptual API call to /chat/get ... */ }
+
+
+    /**
+     * Provides a way to conceptually simulate an incoming webhook request
+     * for testing purposes within this standard library constraint.
+     * This method simulates receiving a raw body and headers and passes them
+     * directly to the internal `processWebhookEvent` method, bypassing the need
+     * for an actual HTTP server listener.
+     * @param {string} rawBody - The raw JSON string payload simulating the request body.
+     * @param {object} [headers={}] - A conceptual headers object simulating request headers. Should include 'x-signature' and 'x-timestamp'.
+     * @returns {Promise<void>} A promise resolving after the simulated processing is complete, or rejecting on error if `processWebhookEvent` throws.
+     * @fires SeaTalkBot#error if `processWebhookEvent` throws an error.
+     */
+    async simulateWebhookRequest(rawBody, headers = {}) {
+        console.log('\n--- SeaTalkBot Simulation: Starting Incoming Webhook Request ---');
+        console.log('Simulated Headers:', headers);
+        // console.log('Simulated Raw Body:', rawBody); // Be careful with logging sensitive data
+
+        // Simulate the processWebhookEvent call that a real server handler would make
+        try {
+             // Call the core processing method directly
+            await this.processWebhookEvent(rawBody, headers['x-signature'], headers['x-timestamp']);
+            console.log('SeaTalkBot Simulation: Processing successful.');
+            // Simulate sending a 200 OK response conceptually
+            console.log('SeaTalkBot Simulation: Conceptual Response -> 200 OK');
+
+        } catch (error) {
+            // Catch errors thrown by processWebhookEvent (validation, parsing, signature, token, command handler errors)
+            console.error('SeaTalkBot Simulation: Processing failed:', error);
+            // Determine a conceptual HTTP status code based on the error type
+            const statusCode = error instanceof InvalidConfigurationError || error instanceof MessageParsingError ? 400 : // Client/parsing error
+                               error instanceof ApiError && error.statusCode === 401 ? 401 : // Authentication/Signature/Token error
+                               500; // Any other unexpected error (CommandExecutionError, etc.)
+             console.log(`SeaTalkBot Simulation: Conceptual Response -> ${statusCode} Error: ${error.message}`);
+            // Re-throw the error so the caller of simulateWebhookRequest can handle it if needed
+            throw error;
+        } finally {
+             console.log('--- SeaTalkBot Simulation: End Incoming Webhook Request ---');
+        }
+    }
+
+} // End of SeaTalkBot class
+
+
+// --- Exports ---
+
+/**
+ * The main export of the package is the SeaTalkBot class.
+ * Custom error classes are also exported to allow users to catch specific error types.
+ * Other utility classes or functions could be exported if intended for public use,
+ * but are kept internal by default unless explicitly added here.
+ */
+module.exports = {
+    SeaTalkBot,
+    InvalidConfigurationError,
+    MessageParsingError,
+    CommandExecutionError,
+    ApiError,
+    // Optionally export event/message structures or managers if the user needs to work with them directly
+    // SeaTalkEvent,
+    // SeaTalkMessageEvent,
+    // MessageParser, // Useful for testing raw payloads
+    // CommandManager // Useful for external command management or introspection
+};
+
+// --- Example Usage (Commented Out) ---
+// This section demonstrates how the exported SeaTalkBot class might be used.
+// It is commented out so the file only contains the library code.
+/*
+const botConfigExample = {
+    appId: 'YOUR_SEATALK_APP_ID', // Replace with your actual App ID
+    appSecret: 'YOUR_SEATALK_APP_SECRET', // Replace with your actual App Secret
+    verificationToken: 'YOUR_SEATALK_VERIFICATION_TOKEN', // Replace with your actual Verification Token
+    // webhookPort: 8080 // Optional, defaults to 8080
+};
+
+// To run this example, you would uncomment the following code block
+// and replace placeholder values with your actual SeaTalk bot credentials.
+// Note that this example uses the simulateWebhookRequest method
+// and conceptual sendMessage/getAccessToken methods due to the
+// "standard library only" constraint. In a real app, you would
+// use a Node.js HTTP server and actual API calls.
+
+try {
+    // Create a new bot instance
+    const bot = new SeaTalkBot(botConfigExample);
+
+    // --- Register Command Handlers ---
+    // Define functions that will run when specific commands are received.
+    bot.registerCommand('echo', async (messageEvent, args) => {
+        console.log(`[Handler: /echo] Received command from ${messageEvent.senderUserId}. Args: ${args.join(' ')}`);
+        const textToEcho = args.length > 0 ? args.join(' ') : 'Nothing to echo!';
+        const responseText = `Echo: ${textToEcho}`;
+        try {
+            // Use the conceptual sendMessage method
+            await bot.sendMessage(messageEvent.openChatId, responseText);
+            console.log(`[Handler: /echo] Sent echo response to ${messageEvent.openChatId}.`);
+        } catch (error) {
+            console.error(`[Handler: /echo] Failed to send echo response:`, error);
+             // The bot's 'error' event listener will also catch this ApiError
+        }
+    });
+
+     bot.registerCommand('help', async (messageEvent, args) => {
+         console.log(`[Handler: /help] Received command from ${messageEvent.senderUserId}.`);
+         const commands = bot.getRegisteredCommands().map(cmd => `/${cmd}`).join(', ');
+         const responseText = `Hello! I'm a SeaTalk Bot. Available commands: ${commands}.`;
+         try {
+             await bot.sendMessage(messageEvent.openChatId, responseText);
+              console.log(`[Handler: /help] Sent help response to ${messageEvent.openChatId}.`);
+         } catch (error) {
+             console.error(`[Handler: /help] Failed to send help response:`, error);
+              // The bot's 'error' event listener will also catch this ApiError
+         }
+     });
+
+    // You can register more commands here...
+    // bot.registerCommand('status', async (messageEvent, args) => { ... });
+
+
+    // --- Listen for Bot Events ---
+    // Attach listeners to events emitted by the bot instance.
+
+    bot.on('initialized', () => {
+        console.log('[Event: initialized] Bot instance successfully created.');
+        console.log('Bot Configuration:', bot.getConfig());
+    });
+
+    bot.on('ready', () => {
+        console.log('[Event: ready] Bot is conceptually ready to process events.');
+        // In a real app, this is where you would start your actual HTTP server
+        // to listen for incoming SeaTalk webhook requests.
+        // Example: bot.startWebhookServer(); // This method is conceptual here
+    });
+
+    // Listen for any incoming processed event
+    bot.on('event', (event) => {
+        console.log(`[Event: event] Received a processed event (Type: ${event.eventType}, Chat: ${event.openChatId || 'N/A'})`);
+        // This general event is useful for logging all incoming events regardless of type.
+    });
+
+    // Listen specifically for message events
+    bot.on('message', (messageEvent) => {
+        console.log(`[Event: message] Received a message event (ID: ${messageEvent.messageId}, Type: ${messageEvent.messageType}) from ${messageEvent.senderUserId} in chat ${messageEvent.openChatId}`);
+        // This is a good place for logic that applies to all messages (e.g., logging, basic filtering)
+        // or handling non-command text messages if not handled elsewhere.
+        const text = messageEvent.getTextContent();
+        if (messageEvent.messageType === 'text' && text !== null) {
+             const commandInfo = parseCommand(text);
+             if (!commandInfo.command) {
+                 console.log(`[Event: message] Handling non-command text: "${text.substring(0, 50)}..."`);
+                 // Example: Simple auto-reply to any non-command text
+                 // bot.sendMessage(messageEvent.openChatId, "Thanks! I received your message. Try typing /help to see what I can do.");
+             }
+        }
+    });
+
+     // Listen specifically for text messages (more specific than 'message')
+     bot.on('message_text', (messageEvent) => {
+          console.log(`[Event: message_text] Received a text message: "${messageEvent.getTextContent().substring(0, 50)}..."`);
+          // Useful if you have different logic for different message types.
+     });
+
+      // Listen specifically for image messages
+      bot.on('message_image', (messageEvent) => {
+           console.log(`[Event: message_image] Received an image message. Content:`, messageEvent.getImageContent());
+           // Handle image messages here (e.g., process image, store key, etc.)
+      });
+
+
+    // Listen specifically for command events (before they are dispatched to handlers)
+    bot.on('command', (commandName, args, messageEvent) => {
+        console.log(`[Event: command] Detected command "${commandName}" from ${messageEvent.senderUserId}. Preparing to dispatch...`);
+         // Useful for logging all commands received or applying pre-dispatch logic (e.g., permission checks)
+    });
+
+     // Listen for commands that were received but not registered
+     bot.on('unregistered_command', (commandName, args, messageEvent) => {
+         console.warn(`[Event: unregistered_command] User ${messageEvent.senderUserId} sent unrecognized command: /${commandName}`);
+         // Inform the user the command is not found (conceptual sendMessage)
+         // try {
+         //     await bot.sendMessage(messageEvent.openChatId, `Sorry, I don't recognize the command "/${commandName}". Type /help for a list of commands.`);
+         // } catch (error) {
+         //      console.error('Failed to send unregistered command message:', error);
+         // }
+     });
+
+
+    // Listen for any errors that occur within the bot's operations
+    bot.on('error', (error, context) => {
+        console.error('[Event: error] Bot encountered an error:', error);
+        if (context) {
+             console.error('Error context:', context);
+        }
+        // Implement robust error logging, monitoring, alerting, etc. here.
+        // For webhook processing errors (signature, parsing, token), the processing method
+        // also throws the error, which your HTTP server handler should catch to send a response.
+        // This event provides an additional asynchronous notification mechanism.
+    });
+
+     // Listen for specific security-related failures
+     bot.on('signature_verification_failed', (context) => {
+          console.error('[Event: signature_verification_failed] Webhook failed signature check! This could indicate a security issue.');
+          console.error('Failed signature context:', context);
+          // Log context securely, trigger alerts.
+     });
+
+      bot.on('token_verification_failed', (context) => {
+          console.error('[Event: token_verification_failed] Webhook verification token mismatch!');
+          console.error('Failed token context:', context);
+          // Log context, trigger alerts.
+      });
+
+       bot.on('parsing_error', (error, rawBody) => {
+           console.error('[Event: parsing_error] Failed to parse or validate webhook payload:', error);
+           // Log rawBody carefully if needed for debugging, but avoid logging sensitive info in production logs.
+       });
+
+
+    // --- Simulate Incoming Webhook Requests (for testing within constraint) ---
+    // In a real application, your HTTP server would receive requests and call
+    // bot.processWebhookEvent(rawBody, signatureHeader, timestampHeader).
+    // Here, we simulate that process.
+
+    // Example Simulated Webhook Payload: A text message containing a command
+    const exampleCommandPayload = {
+         "event_type": "message",
+         "token": botConfigExample.verificationToken, // MUST match configured token
+         "timestamp": String(getCurrentTimestampInSeconds()), // MUST be relatively fresh
+         "open_chat_id": "oc_example_chat_id", // Example chat ID
+         "open_app_id": botConfigExample.appId, // MUST match configured appId
+         "message": {
+             "message_id": "om_example_msg_id_1",
+             "chat_type": "p2p", // or "group"
+             "open_chat_id": "oc_example_chat_id",
+             "sender_type": "user", // or "bot"
+             "sender_user_id": "ou_example_user_id", // Example user ID
+             "message_type": "text",
+             "create_time": String(getCurrentTimestampInSeconds()),
+             "content": {
+                 "text": "/echo Hello SeaTalk Bot!" // The command text
+             },
+             "parent_id": "", // if a reply
+             "open_message_id": "om_example_msg_id_1" // typically same as message_id
+         },
+         "sender": {
+             "tenant_user_id": "example_tenant_user" // Example tenant user ID
+             // other sender details might be here
+         }
+    };
+
+     const exampleCommandRawBody = JSON.stringify(exampleCommandPayload);
+     // Simulate signature header - MUST match the logic in simulateSignatureVerification
+     // Our simulation expects 'valid_signature_for_' + first 8 chars of app secret
+     const exampleCommandSignature = 'valid_signature_for_' + botConfigExample.appSecret.substring(0, 8);
+     const exampleCommandTimestamp = exampleCommandPayload.timestamp; // Use the timestamp from the payload
+
+     console.log('\n--- Running Simulation: Command Message ---');
+     bot.simulateWebhookRequest(exampleCommandRawBody, {
+          'x-signature': exampleCommandSignature,
+          'x-timestamp': exampleCommandTimestamp
+     })
+     .then(() => console.log('Simulation Complete: Command Message.'))
+     .catch(err => console.error('Simulation Ended with Error: Command Message:', err));
+
+
+      // Example Simulated Webhook Payload: A plain text message (not a command)
+     const examplePlainMessagePayload = {
+         "event_type": "message",
+         "token": botConfigExample.verificationToken,
+         "timestamp": String(getCurrentTimestampInSeconds() + 1), // Slightly different timestamp
+         "open_chat_id": "oc_another_chat",
+         "open_app_id": botConfigExample.appId,
+         "message": {
+             "message_id": "om_example_msg_id_2",
+             "chat_type": "group",
+             "open_chat_id": "oc_another_chat",
+             "sender_type": "user",
+             "sender_user_id": "ou_another_user_id",
+             "message_type": "text",
+             "create_time": String(getCurrentTimestampInSeconds() + 1),
+             "content": {
+                 "text": "Just saying hi!" // Plain text
+             },
+              "parent_id": "",
+              "open_message_id": "om_example_msg_id_2"
+         },
+          "sender": {
+              "tenant_user_id": "another_tenant_user"
+          }
+     };
+     const examplePlainMessageRawBody = JSON.stringify(examplePlainMessagePayload);
+      // Simulate signature and timestamp
+      const examplePlainMessageSignature = 'valid_signature_for_' + botConfigExample.appSecret.substring(0, 8);
+      const examplePlainMessageTimestamp = examplePlainMessagePayload.timestamp;
+
+      console.log('\n--- Running Simulation: Plain Message ---');
+      bot.simulateWebhookRequest(examplePlainMessageRawBody, {
+           'x-signature': examplePlainMessageSignature,
+           'x-timestamp': examplePlainMessageTimestamp
+      })
+      .then(() => console.log('Simulation Complete: Plain Message.'))
+      .catch(err => console.error('Simulation Ended with Error: Plain Message:', err));
+
+
+       // Example Simulated Webhook Payload: Unregistered command
+      const exampleUnregisteredCommandPayload = {
+          "event_type": "message",
+          "token": botConfigExample.verificationToken,
+          "timestamp": String(getCurrentTimestampInSeconds() + 2),
+          "open_chat_id": "oc_another_chat",
+          "open_app_id": botConfigExample.appId,
+          "message": {
+              "message_id": "om_example_msg_id_3",
+              "chat_type": "p2p",
+              "open_chat_id": "oc_another_chat",
+              "sender_type": "user",
+              "sender_user_id": "ou_another_user_id",
+              "message_type": "text",
+              "create_time": String(getCurrentTimestampInSeconds() + 2),
+              "content": {
+                  "text": "/unknowncommand arg1" // Unregistered command
+              },
+               "parent_id": "",
+               "open_message_id": "om_example_msg_id_3"
+          },
+           "sender": {
+               "tenant_user_id": "another_tenant_user"
+           }
+      };
+      const exampleUnregisteredCommandRawBody = JSON.stringify(exampleUnregisteredCommandPayload);
+       const exampleUnregisteredCommandSignature = 'valid_signature_for_' + botConfigExample.appSecret.substring(0, 8);
+       const exampleUnregisteredCommandTimestamp = exampleUnregisteredCommandPayload.timestamp;
+
+       console.log('\n--- Running Simulation: Unregistered Command ---');
+       bot.simulateWebhookRequest(exampleUnregisteredCommandRawBody, {
+            'x-signature': exampleUnregisteredCommandSignature,
+            'x-timestamp': exampleUnregisteredCommandTimestamp
+       })
+       .then(() => console.log('Simulation Complete: Unregistered Command.'))
+       .catch(err => console.error('Simulation Ended with Error: Unregistered Command:', err));
+
+
+        // Example Simulated Webhook Request: Bad Signature
+       const exampleBadSignaturePayload = {
+           "event_type": "message",
+           "token": botConfigExample.verificationToken,
+           "timestamp": String(getCurrentTimestampInSeconds() + 3),
+           "open_chat_id": "oc_bad_sig_chat",
+           "open_app_id": botConfigExample.appId,
+           "message": { // Message content doesn't really matter for signature failure
+               "message_id": "om_example_msg_id_4",
+               "chat_type": "p2p",
+               "open_chat_id": "oc_bad_sig_chat",
+               "sender_type": "user",
+               "sender_user_id": "ou_bad_sig_user_id",
+               "message_type": "text",
+               "create_time": String(getCurrentTimestampInSeconds() + 3),
+               "content": { "text": "This should fail signature check." },
+                "parent_id": "",
+                "open_message_id": "om_example_msg_id_4"
+           },
+            "sender": { "tenant_user_id": "bad_sig_user" }
+       };
+       const exampleBadSignatureRawBody = JSON.stringify(exampleBadSignaturePayload);
+       // Simulate a BAD signature that doesn't match the expected format
+       const exampleBadSignature = 'invalid_signature_prefix' + botConfigExample.appSecret.substring(0, 8); // Intentional mismatch
+       const exampleBadSignatureTimestamp = exampleBadSignaturePayload.timestamp;
+
+       console.log('\n--- Running Simulation: Bad Signature ---');
+        bot.simulateWebhookRequest(exampleBadSignatureRawBody, {
+             'x-signature': exampleBadSignature,
+             'x-timestamp': exampleBadSignatureTimestamp
+        })
+        .then(() => console.log('Simulation Complete: Bad Signature (Processed).')) // processWebhookEvent will throw, not resolve
+        .catch(err => console.error('Simulation Ended with Error: Bad Signature:', err));
+
+
+       // Example Simulated Webhook Request: Bad Verification Token in Payload
+      const exampleBadTokenPayload = {
+          "event_type": "message",
+          "token": "THIS_IS_AN_INVALID_TOKEN", // Intentional mismatch
+          "timestamp": String(getCurrentTimestampInSeconds() + 4),
+          "open_chat_id": "oc_bad_token_chat",
+          "open_app_id": botConfigExample.appId,
+          "message": {
+              "message_id": "om_example_msg_id_5",
+              "chat_type": "p2p",
+              "open_chat_id": "oc_bad_token_chat",
+              "sender_type": "user",
+              "sender_user_id": "ou_bad_token_user_id",
+              "message_type": "text",
+              "create_time": String(getCurrentTimestampInSeconds() + 4),
+              "content": { "text": "This should fail token check." },
+               "parent_id": "",
+               "open_message_id": "om_example_msg_id_5"
+          },
+           "sender": { "tenant_user_id": "bad_token_user" }
+      };
+       const exampleBadTokenRawBody = JSON.stringify(exampleBadTokenPayload);
+        // Signature should still be correct to reach token check in this simulation flow
+       const exampleBadTokenSignature = 'valid_signature_for_' + botConfigExample.appSecret.substring(0, 8);
+       const exampleBadTokenTimestamp = exampleBadTokenPayload.timestamp;
+
+       console.log('\n--- Running Simulation: Bad Verification Token ---');
+       bot.simulateWebhookRequest(exampleBadTokenRawBody, {
+            'x-signature': exampleBadTokenSignature,
+            'x-timestamp': exampleBadTokenTimestamp
+       })
+       .then(() => console.log('Simulation Complete: Bad Verification Token (Processed).'))
+       .catch(err => console.error('Simulation Ended with Error: Bad Verification Token:', err));
+
+
+        // Example Simulated Webhook Request: Invalid JSON Body
+       const exampleInvalidJsonRawBody = '{"event_type": "message", "token": "' + botConfigExample.verificationToken + '", "timestamp": "' + String(getCurrentTimestampInSeconds() + 5) + '", invalid_json}'; // Malformed JSON
+        // Signature and timestamp headers might not even be checked if body reading/parsing fails first in a real server
+       const exampleInvalidJsonSignature = 'valid_signature_for_' + botConfigExample.appSecret.substring(0, 8);
+       const exampleInvalidJsonTimestamp = String(getCurrentTimestampInSeconds() + 5);
+
+       console.log('\n--- Running Simulation: Invalid JSON Body ---');
+       bot.simulateWebhookRequest(exampleInvalidJsonRawBody, {
+            'x-signature': exampleInvalidJsonSignature,
+            'x-timestamp': exampleInvalidJsonTimestamp
+       })
+       .then(() => console.log('Simulation Complete: Invalid JSON (Processed).'))
+       .catch(err => console.error('Simulation Ended with Error: Invalid JSON:', err));
+
+
+} catch (initError) {
+    console.error('Failed to initialize SeaTalk Bot instance:', initError);
+    // Bot could not be created, possibly due to invalid configuration
+}
+
+// In a real application, after setting up event listeners and registering commands,
+// you would typically start the webhook server here:
+// bot.startWebhookServer(); // This is the conceptual method defined above
+
+// The process would then wait for incoming HTTP requests handled by the server.
+*/
+// End of Example Usage