add basic console commands

Author: garredow

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nothing-special/kaiware-lib",
-	"version": "0.7.0",
+	"version": "0.8.0",
 	"type": "module",
 	"author": {
 		"name": "Garrett Downs",
@@ -13,6 +13,7 @@
 	},
 	"scripts": {
 		"build": "rimraf build && rollup -c --bundleConfigAsCjs",
+		"build:watch": "rimraf build && rollup -c --bundleConfigAsCjs --watch",
 		"format": "prettier --check .",
 		"format:fix": "prettier --check --write .",
 		"lint": "eslint .",

src/enums/MessageType.ts

@@ -26,6 +26,9 @@ export enum MessageType {
 	ClearLogs = 'clear-logs',
 	ClearLogsRes = 'clear-logs-res',
 
+	ExecuteConsoleCommand = 'execute-console-command',
+	ExecuteConsoleCommandRes = 'execute-console-command-res',
+
 	// Misc
 
 	NewLog = 'new-log',

src/lib/connection.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { MessageType } from '../enums';
-import { Config, MessageWithId, rawMessageSchema } from '../types';
+import { Config, ConsoleCommandResPayload, MessageWithId, rawMessageSchema } from '../types';
+import { makeSerializable, parseConsoleCommand, stringifyObject } from '../utils';
 
 export class Connection {
 	private config: Config;
@@ -61,6 +62,9 @@ export class Connection {
 					case MessageType.GetStorage:
 						this.handleGetStorage(message);
 						break;
+					case MessageType.ExecuteConsoleCommand:
+						this.handleConsoleCommand(message);
+						break;
 					default:
 						this.cleanConsole.log(`Unknown message type received: ${message.type}`);
 						break;
@@ -198,6 +202,54 @@ export class Connection {
 			data: { index: message.data.index, data: {} }
 		});
 	}
+
+	private async handleConsoleCommand(
+		message: MessageWithId & { type: MessageType.ExecuteConsoleCommand }
+	) {
+		const consoleCommand = parseConsoleCommand(message.data.command);
+
+		let response: ConsoleCommandResPayload = {};
+		let currentValue: unknown = window;
+		try {
+			for (const step of consoleCommand.steps) {
+				switch (step.type) {
+					case 'property':
+						// eslint-disable-next-line @typescript-eslint/no-explicit-any
+						currentValue = (currentValue as any)[step.value];
+						break;
+					case 'function':
+						// eslint-disable-next-line @typescript-eslint/no-explicit-any
+						currentValue = await (currentValue as any)[step.value](...step.params);
+						break;
+					case 'array':
+						// eslint-disable-next-line @typescript-eslint/no-explicit-any
+						currentValue = (currentValue as any)[Number(step.value)];
+						break;
+				}
+			}
+
+			let responseData;
+			if (typeof currentValue === 'object' && !Array.isArray(currentValue)) {
+				responseData = stringifyObject(currentValue ?? {});
+				console.log('responseData', responseData);
+			} else if (Array.isArray(currentValue)) {
+				responseData = currentValue.map((val) => makeSerializable(val));
+			}
+
+			response = {
+				result: responseData
+			};
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		} catch (err: any) {
+			response = { error: err?.message ?? 'Unknown error' };
+		}
+
+		this.sendMessage({
+			requestId: message.requestId,
+			type: MessageType.ExecuteConsoleCommandRes,
+			data: response
+		});
+	}
 }
 
 function formatValidationError(issues: z.ZodIssue[]) {

src/types/schemas.ts

@@ -113,6 +113,7 @@ export type ClearLogsResPayload = z.infer<typeof clearLogsResPayloadSchema>;
 
 // NetworkRequest
 export const networkRequestSchema = z.object({
+	id: z.number(),
 	requestId: z.string(),
 	url: z.string(),
 	method: z.union([
@@ -133,6 +134,7 @@ export const networkRequestSchema = z.object({
 	body: z.string().optional(),
 	startTime: z.number(),
 	endTime: z.number().optional(),
+	duration: z.number().optional(),
 	responseStatus: z.number().optional(),
 	responseHeaders: z.array(z.object({ key: z.string(), value: z.string() })).optional(),
 	responseBody: z.string().optional(),
@@ -166,13 +168,37 @@ export const networkRequestUpdateResPayload = z.object({
 	body: z.string().optional(),
 	startTime: z.number().optional(),
 	endTime: z.number().optional(),
+	duration: z.number().optional(),
 	responseStatus: z.number().optional(),
 	responseHeaders: z.array(z.object({ key: z.string(), value: z.string() })).optional(),
 	responseBody: z.string().optional(),
 	responseSize: z.number().optional()
 });
 export type NetworkRequestUpdateResPayload = z.infer<typeof networkRequestUpdateResPayload>;
 
+// ConsoleCommandPayload
+export const consoleCommandPayloadSchema = z.object({
+	command: z.string()
+});
+export type ConsoleCommandPayload = z.infer<typeof consoleCommandPayloadSchema>;
+
+// ConsoleCommandResPayload
+export const consoleCommandResPayloadSchema = z.object({
+	result: z.unknown().optional(),
+	error: z.string().optional()
+});
+export type ConsoleCommandResPayload = z.infer<typeof consoleCommandResPayloadSchema>;
+
+export type ConsoleCommand = {
+	steps: CommandStep[];
+};
+
+export type CommandStep = {
+	type: 'property' | 'function' | 'array';
+	value: string;
+	params: unknown[];
+};
+
 // Message
 export const messageSchema = z.discriminatedUnion('type', [
 	z.object({
@@ -274,6 +300,16 @@ export const messageSchema = z.discriminatedUnion('type', [
 		requestId: z.string(),
 		type: z.literal(MessageType.NetworkRequestUpdate),
 		data: networkRequestUpdateResPayload
+	}),
+	z.object({
+		requestId: z.string(),
+		type: z.literal(MessageType.ExecuteConsoleCommand),
+		data: consoleCommandPayloadSchema
+	}),
+	z.object({
+		requestId: z.string(),
+		type: z.literal(MessageType.ExecuteConsoleCommandRes),
+		data: consoleCommandResPayloadSchema
 	})
 ]);
 type OmitRequestId<T> = {

src/utils/getObjectKeys.ts

@@ -0,0 +1,7 @@
+export function getObjectKeys(obj: object): string[] {
+	const keys: string[] = [];
+	for (const key in obj) {
+		keys.push(key);
+	}
+	return keys;
+}

src/utils/index.ts

@@ -1,2 +1,6 @@
+export * from './getObjectKeys';
 export * from './isJson';
+export * from './makeSerializable';
+export * from './parseConsoleCommand';
 export * from './parseError';
+export * from './stringifyObject';

src/utils/makeSerializable.ts

@@ -0,0 +1,12 @@
+import { getObjectKeys } from './getObjectKeys';
+
+export function makeSerializable(obj: object, spaces = 2): object {
+	const newObj: { [key: string]: unknown } = {};
+
+	const keys = getObjectKeys(obj);
+	keys.forEach((key) => {
+		newObj[key] = (obj as { [key: string]: unknown })[key];
+	});
+
+	return JSON.parse(JSON.stringify(newObj, null, spaces));
+}

src/utils/parseConsoleCommand.ts

@@ -0,0 +1,49 @@
+import { CommandStep, ConsoleCommand } from '../types';
+
+export function parseConsoleCommand(command: string): ConsoleCommand {
+	const steps = command.match(/(\w+\[\d+\])|(\w+\([^)]*\))|(\w+)/g);
+	const result: CommandStep[] = [];
+
+	steps?.forEach((step) => {
+		let matches;
+		if ((matches = step.match(/^(\w+)\((.*)\)$/))) {
+			result.push(createStep('function', matches as RegExpMatchArray));
+		} else if ((matches = step.match(/^(\w+)\[(.*?)\]$/))) {
+			result.push(createStep('array', matches as RegExpMatchArray));
+		} else {
+			result.push({
+				type: 'property',
+				value: step,
+				params: []
+			});
+		}
+	});
+
+	return {
+		steps: result
+	};
+}
+
+function createStep(type: CommandStep['type'], matches: RegExpMatchArray): CommandStep {
+	return {
+		type,
+		value: matches[1] as string,
+		params: parseParams(matches[2] as string)
+	};
+}
+
+function parseParams(paramString: string): unknown[] {
+	const matches = paramString.match(/(\d+)|('[^']*')|("[^"]*")|(\[[^\]]*\])|({[^}]*})/g);
+	if (!matches) return [];
+
+	return matches.map((match) => {
+		if (match.startsWith('[') || match.startsWith('{')) {
+			return JSON.parse(match);
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		} else if (!isNaN(match as any)) {
+			return Number(match);
+		} else {
+			return match.slice(1, -1);
+		}
+	});
+}

src/utils/stringifyObject.ts

@@ -0,0 +1,6 @@
+import { getObjectKeys } from './getObjectKeys';
+
+export function stringifyObject(obj: object, spaces = 2): string {
+	const keys = getObjectKeys(obj);
+	return JSON.stringify(obj, keys, spaces);
+}