@athree/runner-proto 2.0.0

package/package.json

@@ -0,0 +1,12 @@
+{
+    "name": "@athree/runner-proto",
+    "version": "2.0.0",
+    "type": "module",
+    "sideEffects": false,
+    "exports": {
+        ".": "./out/main/index.js"
+    },
+    "scripts": {
+        "clean": "rm -rf out/ *.tsbuildinfo"
+    }
+}

package/src/main/domains/BrowserDomain.ts

@@ -0,0 +1,166 @@
+import { DomainDef } from '@nodescript/protocomm';
+import { Event } from 'nanoevent';
+
+import { KeyboardEventRequest } from '../schema/KeyboardEventRequest.js';
+import { MouseEventRequest } from '../schema/MouseEventRequest.js';
+import { ScreencastFrame } from '../schema/ScreencastFrame.js';
+
+export interface BrowserDomain {
+
+    getUrl(req: {}): Promise<{
+        url: string;
+    }>;
+
+    goto(req: {
+        url: string;
+        waitUntil?: 'load' | 'domcontentloaded' | 'networkidle';
+    }): Promise<{}>;
+
+    sendCdpCommand(req: {
+        command: string;
+        params: any;
+    }): Promise<{
+        result: any;
+    }>;
+
+    startScreencast(req: {}): Promise<{}>;
+
+    stopScreencast(req: {}): Promise<{}>;
+
+    dispatchMouseEvent(req: MouseEventRequest): Promise<{}>;
+
+    dispatchKeyboardEvent(req: KeyboardEventRequest): Promise<{}>;
+
+    getViewportSize(req: {}): Promise<{
+        width: number;
+        height: number;
+    }>;
+
+    setViewportSize(req: {
+        width: number;
+        height: number;
+    }): Promise<{}>;
+
+    urlChanged: Event<{
+        url: string;
+    }>;
+
+    screencastFrame: Event<ScreencastFrame>;
+
+}
+
+export const BrowserDomain: DomainDef<BrowserDomain> = {
+    name: 'Browser',
+    methods: {
+        getUrl: {
+            type: 'query',
+            params: {},
+            returns: {
+                url: { type: 'string' },
+            },
+        },
+        goto: {
+            type: 'command',
+            params: {
+                url: { type: 'string' },
+                waitUntil: {
+                    type: 'string',
+                    enum: [
+                        'load',
+                        'domcontentloaded',
+                        'networkidle',
+                    ],
+                    optional: true,
+                },
+            },
+            returns: {},
+        },
+        sendCdpCommand: {
+            type: 'command',
+            params: {
+                command: { type: 'string' },
+                params: { type: 'any' },
+            },
+            returns: {
+                result: { type: 'any' },
+            },
+        },
+        startScreencast: {
+            type: 'command',
+            params: {},
+            returns: {},
+        },
+        stopScreencast: {
+            type: 'command',
+            params: {},
+            returns: {},
+        },
+        dispatchMouseEvent: {
+            type: 'command',
+            params: {
+                type: {
+                    type: 'string',
+                    enum: ['mousedown', 'mouseup', 'mousemove', 'wheel'],
+                },
+                x: { type: 'number' },
+                y: { type: 'number' },
+                button: {
+                    type: 'string',
+                    enum: ['left', 'right', 'middle'],
+                    optional: true,
+                },
+                buttons: { type: 'number', optional: true },
+                clickCount: { type: 'number', optional: true },
+                deltaX: { type: 'number', optional: true },
+                deltaY: { type: 'number', optional: true },
+                modifiers: { type: 'number', optional: true },
+            },
+            returns: {},
+        },
+        dispatchKeyboardEvent: {
+            type: 'command',
+            params: {
+                type: {
+                    type: 'string',
+                    enum: ['keydown', 'keyup', 'keypress'],
+                },
+                key: { type: 'string', optional: true },
+                code: { type: 'string', optional: true },
+                text: { type: 'string', optional: true },
+                modifiers: { type: 'number', optional: true },
+            },
+            returns: {},
+        },
+        getViewportSize: {
+            type: 'query',
+            params: {},
+            returns: {
+                width: { type: 'number' },
+                height: { type: 'number' },
+            },
+        },
+        setViewportSize: {
+            type: 'command',
+            params: {
+                width: { type: 'number' },
+                height: { type: 'number' },
+            },
+            returns: {},
+        },
+    },
+    events: {
+        urlChanged: {
+            params: {
+                url: { type: 'string' },
+            },
+        },
+        screencastFrame: {
+            params: {
+                sessionId: { type: 'number' },
+                data: { type: 'string' },
+                width: { type: 'number' },
+                height: { type: 'number' },
+            },
+        },
+    },
+};

package/src/main/domains/EvalDomain.ts

@@ -0,0 +1,30 @@
+import { DomainDef } from '@nodescript/protocomm';
+
+import { EvaluateRequest, EvaluateRequestSchema } from '../schema/EvaluateRequest.js';
+import { EvaluateResponse, EvaluateResponseSchema } from '../schema/EvaluateResponse.js';
+
+export interface EvalDomain {
+
+    evaluate(req: {
+        request: EvaluateRequest;
+    }): Promise<{
+        response: EvaluateResponse;
+    }>;
+
+}
+
+export const EvalDomain: DomainDef<EvalDomain> = {
+    name: 'Eval',
+    methods: {
+        evaluate: {
+            type: 'command',
+            params: {
+                request: EvaluateRequestSchema.schema,
+            },
+            returns: {
+                response: EvaluateResponseSchema.schema,
+            },
+        },
+    },
+    events: {},
+};

package/src/main/domains/MessageDomain.ts

@@ -0,0 +1,64 @@
+import { DomainDef } from '@nodescript/protocomm';
+import { Event } from 'nanoevent';
+
+import { WorkflowMessage, WorkflowMessageSchema } from '../schema/WorkflowMessage.js';
+
+export interface MessageDomain {
+
+    getMessages(req: {}): Promise<{
+        messages: WorkflowMessage[];
+    }>;
+
+    clearMessages(req: {}): Promise<{}>;
+
+    messageAdded: Event<{
+        message: WorkflowMessage;
+    }>;
+
+    messageUpdated: Event<{
+        messageId: string;
+        content: string;
+    }>;
+
+    messagesCleared: Event<{}>;
+
+}
+
+export const MessageDomain: DomainDef<MessageDomain> = {
+    name: 'Message',
+    methods: {
+        getMessages: {
+            type: 'query',
+            params: {},
+            returns: {
+                messages: {
+                    type: 'array',
+                    items: WorkflowMessageSchema.schema,
+                },
+            },
+        },
+        clearMessages: {
+            type: 'command',
+            params: {
+                workflowId: { type: 'string' },
+            },
+            returns: {},
+        },
+    },
+    events: {
+        messageAdded: {
+            params: {
+                message: WorkflowMessageSchema.schema,
+            },
+        },
+        messageUpdated: {
+            params: {
+                messageId: { type: 'string' },
+                content: { type: 'string' },
+            },
+        },
+        messagesCleared: {
+            params: {},
+        },
+    },
+};

package/src/main/domains/StateDomain.ts

@@ -0,0 +1,75 @@
+import { DomainDef } from '@nodescript/protocomm';
+import { Event } from 'nanoevent';
+
+export interface StateDomain {
+
+    getState(req: {}): Promise<{
+        data: Record<string, any>;
+    }>;
+
+    setStateData(req: {
+        key: string;
+        value: any;
+    }): Promise<{}>;
+
+    clearState(req: {}): Promise<{}>;
+
+    stateCleared: Event<{}>;
+
+    stateUpdated: Event<{
+        key: string;
+        value: any;
+    }>;
+
+}
+
+export const StateDomain: DomainDef<StateDomain> = {
+    name: 'State',
+    methods: {
+        getState: {
+            type: 'query',
+            params: {},
+            returns: {
+                data: {
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: {
+                        type: 'any',
+                    },
+                },
+            },
+        },
+        setStateData: {
+            type: 'command',
+            params: {
+                key: {
+                    type: 'string',
+                },
+                value: {
+                    type: 'any',
+                },
+            },
+            returns: {},
+        },
+        clearState: {
+            type: 'command',
+            params: {},
+            returns: {},
+        },
+    },
+    events: {
+        stateCleared: {
+            params: {},
+        },
+        stateUpdated: {
+            params: {
+                key: {
+                    type: 'string',
+                },
+                value: {
+                    type: 'any',
+                },
+            },
+        },
+    },
+};

package/src/main/index.ts

@@ -0,0 +1,13 @@
+export * from './domains/BrowserDomain.js';
+export * from './domains/EvalDomain.js';
+export * from './domains/MessageDomain.js';
+export * from './domains/StateDomain.js';
+export * from './protocol.js';
+export * from './schema/EvaluateRequest.js';
+export * from './schema/EvaluateResponse.js';
+export * from './schema/KeyboardEventRequest.js';
+export * from './schema/MouseEventRequest.js';
+export * from './schema/PageMetadata.js';
+export * from './schema/ScreencastFrame.js';
+export * from './schema/WorkflowInfo.js';
+export * from './schema/WorkflowMessage.js';

package/src/main/protocol.ts

@@ -0,0 +1,20 @@
+import { ProtocolIndex } from '@nodescript/protocomm';
+
+import { BrowserDomain } from './domains/BrowserDomain.js';
+import { EvalDomain } from './domains/EvalDomain.js';
+import { MessageDomain } from './domains/MessageDomain.js';
+import { StateDomain } from './domains/StateDomain.js';
+
+export interface RunnerProtocol {
+    Browser: BrowserDomain;
+    Eval: EvalDomain;
+    State: StateDomain;
+    Message: MessageDomain;
+}
+
+export const runnerProtocol = new ProtocolIndex<RunnerProtocol>({
+    Browser: BrowserDomain,
+    Eval: EvalDomain,
+    State: StateDomain,
+    Message: MessageDomain,
+});

package/src/main/schema/EvaluateRequest.ts

@@ -0,0 +1,18 @@
+import { Schema } from 'airtight';
+
+export interface EvaluateRequest {
+    code: string;
+    args: Record<string, unknown>;
+}
+
+export const EvaluateRequestSchema = new Schema<EvaluateRequest>({
+    type: 'object',
+    properties: {
+        code: { type: 'string' },
+        args: {
+            type: 'object',
+            properties: {},
+            additionalProperties: { type: 'any' },
+        },
+    },
+});

package/src/main/schema/EvaluateResponse.ts

@@ -0,0 +1,27 @@
+import { Schema } from 'airtight';
+
+export interface EvaluateResponse {
+    result?: unknown;
+    error?: {
+        name: string;
+        message: string;
+    };
+}
+
+export const EvaluateResponseSchema = new Schema<EvaluateResponse>({
+    type: 'object',
+    properties: {
+        result: {
+            type: 'any',
+            optional: true,
+        },
+        error: {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+                message: { type: 'string' },
+            },
+            optional: true,
+        },
+    },
+});

package/src/main/schema/KeyboardEventRequest.ts

@@ -0,0 +1,23 @@
+import { Schema } from 'airtight';
+
+export interface KeyboardEventRequest {
+    type: 'keydown' | 'keyup' | 'keypress';
+    key?: string;
+    code?: string;
+    text?: string;
+    modifiers?: number;
+}
+
+export const KeyboardEventRequestSchema = new Schema<KeyboardEventRequest>({
+    type: 'object',
+    properties: {
+        type: {
+            type: 'string',
+            enum: ['keydown', 'keyup', 'keypress'],
+        },
+        key: { type: 'string', optional: true },
+        code: { type: 'string', optional: true },
+        text: { type: 'string', optional: true },
+        modifiers: { type: 'number', optional: true },
+    },
+});

package/src/main/schema/MouseEventRequest.ts

@@ -0,0 +1,35 @@
+import { Schema } from 'airtight';
+
+export interface MouseEventRequest {
+    type: 'mousedown' | 'mouseup' | 'mousemove' | 'wheel';
+    x: number;
+    y: number;
+    button?: 'left' | 'right' | 'middle';
+    buttons?: number;
+    clickCount?: number;
+    deltaX?: number;
+    deltaY?: number;
+    modifiers?: number;
+}
+
+export const MouseEventRequestSchema = new Schema<MouseEventRequest>({
+    type: 'object',
+    properties: {
+        type: {
+            type: 'string',
+            enum: ['mousedown', 'mouseup', 'mousemove', 'wheel'],
+        },
+        x: { type: 'number' },
+        y: { type: 'number' },
+        button: {
+            type: 'string',
+            enum: ['left', 'right', 'middle'],
+            optional: true,
+        },
+        buttons: { type: 'number', optional: true },
+        clickCount: { type: 'number', optional: true },
+        deltaX: { type: 'number', optional: true },
+        deltaY: { type: 'number', optional: true },
+        modifiers: { type: 'number', optional: true },
+    },
+});

package/src/main/schema/PageMetadata.ts

@@ -0,0 +1,22 @@
+import { Schema } from 'airtight';
+
+export interface PageMetadata {
+    id: string;
+    title: string;
+    type: 'page' | 'iframe';
+    url: string;
+    devtoolsFrontendUrl: string;
+    webSocketDebuggerUrl: string;
+}
+
+export const PageMetadataSchema = new Schema<PageMetadata>({
+    type: 'object',
+    properties: {
+        id: { type: 'string' },
+        title: { type: 'string' },
+        type: { type: 'string', enum: ['page', 'iframe'] },
+        url: { type: 'string' },
+        devtoolsFrontendUrl: { type: 'string' },
+        webSocketDebuggerUrl: { type: 'string' },
+    },
+});

package/src/main/schema/ScreencastFrame.ts

@@ -0,0 +1,18 @@
+import { Schema } from 'airtight';
+
+export interface ScreencastFrame {
+    sessionId: number;
+    data: string;
+    width: number;
+    height: number;
+}
+
+export const ScreencastFrameSchema = new Schema<ScreencastFrame>({
+    type: 'object',
+    properties: {
+        sessionId: { type: 'number' },
+        data: { type: 'string' },
+        width: { type: 'number' },
+        height: { type: 'number' },
+    },
+});

package/src/main/schema/WorkflowInfo.ts

@@ -0,0 +1,16 @@
+import { Schema } from 'airtight';
+
+export interface WorkflowInfo {
+    workflowId: string;
+    title: string;
+    description?: string;
+}
+
+export const WorkflowInfoSchema = new Schema<WorkflowInfo>({
+    type: 'object',
+    properties: {
+        workflowId: { type: 'string' },
+        title: { type: 'string' },
+        description: { type: 'string', optional: true },
+    },
+});

package/src/main/schema/WorkflowMessage.ts

@@ -0,0 +1,24 @@
+import { Schema } from 'airtight';
+
+export interface WorkflowMessage {
+    messageId?: string;
+    title?: string;
+    icon?: string;
+    content: string;
+    data?: any;
+    code?: string;
+    timestamp?: number;
+}
+
+export const WorkflowMessageSchema = new Schema<WorkflowMessage>({
+    type: 'object',
+    properties: {
+        messageId: { type: 'string', optional: true },
+        title: { type: 'string', optional: true },
+        icon: { type: 'string', optional: true },
+        content: { type: 'string' },
+        data: { type: 'any', optional: true },
+        code: { type: 'string', optional: true },
+        timestamp: { type: 'number', optional: true },
+    },
+});

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+    "extends": "../../tsconfig.base.json",
+    "compilerOptions": {
+        "outDir": "./out",
+        "rootDir": "./src"
+    },
+    "include": ["src"]
+}