agentq-webdriverio 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 agentq-ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# agentq-webdriverio

package/agentq.config.json

@@ -0,0 +1,3 @@
+{
+  "TOKEN": "efe9c3a612d6196c369c41de02fd63a8d1da8b9f00640daabf799bd01e7b6c1c"
+}

package/dist/commandExecutor.d.ts

@@ -0,0 +1,4 @@
+import { AICommand } from './types';
+export declare class CommandExecutor {
+    static execute(command: AICommand, browser: WebdriverIO.Browser): Promise<void>;
+}

package/dist/commandExecutor.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandExecutor = void 0;
+class CommandExecutor {
+    static async execute(command, browser) {
+        if (command.action === 'fill') {
+            const el = await browser.$(command.target);
+            await el.waitForDisplayed({ timeout: 10000 });
+            await el.setValue(command.value);
+        }
+        else if (command.action === 'click') {
+            const el = await browser.$(command.target);
+            await el.waitForDisplayed({ timeout: 10000 });
+            await el.click();
+        }
+        else if (command.action === 'visit' || command.action === 'goto' || command.action === 'navigate' || command.action === 'open') {
+            await browser.url(command.value);
+        }
+        else if (command.action === 'select') {
+            const el = await browser.$(command.target);
+            await el.waitForDisplayed({ timeout: 10000 });
+            if (typeof command.value === 'object' && command.value !== null && 'value' in command.value) {
+                if (command.value.value) {
+                    await el.selectByAttribute('value', command.value.value);
+                }
+                else if (command.value.label) {
+                    await el.selectByVisibleText(command.value.label);
+                }
+                else if (command.value.index !== undefined) {
+                    await el.selectByIndex(command.value.index);
+                }
+            }
+            else if (typeof command.value === 'string') {
+                await el.selectByVisibleText(command.value);
+            }
+        }
+        else if (command.action === 'check') {
+            const el = await browser.$(command.target);
+            await el.waitForDisplayed({ timeout: 10000 });
+            if (!(await el.isSelected())) {
+                await el.click();
+            }
+        }
+        else if (command.action === 'uncheck') {
+            const el = await browser.$(command.target);
+            await el.waitForDisplayed({ timeout: 10000 });
+            if (await el.isSelected()) {
+                await el.click();
+            }
+        }
+        else if (command.action === 'type') {
+            const el = await browser.$(command.target);
+            await el.waitForDisplayed({ timeout: 10000 });
+            await el.addValue(command.value);
+        }
+        else if (command.action === 'wait') {
+            await browser.pause(command.value);
+        }
+        else if (command.action === 'assertVisible') {
+            const el = await browser.$(command.target);
+            await el.waitForDisplayed({ timeout: 10000 });
+        }
+        else if (command.action === 'assertNotVisible') {
+            const el = await browser.$(command.target);
+            await el.waitForDisplayed({ timeout: 10000, reverse: true });
+        }
+        else if (command.action === 'assertEqual') {
+            const el = await browser.$(command.target);
+            await el.waitForDisplayed({ timeout: 10000 });
+            const textContent = await el.getText();
+            if (textContent !== command.value) {
+                throw new Error(`Expected text "${command.value}" but found "${textContent}"`);
+            }
+        }
+        else if (command.action === 'assertContain') {
+            const el = await browser.$(command.target);
+            await el.waitForDisplayed({ timeout: 10000 });
+            const textContent = await el.getText();
+            if (!textContent.includes(command.value)) {
+                throw new Error(`Expected text to contain "${command.value}" but found "${textContent}"`);
+            }
+        }
+    }
+}
+exports.CommandExecutor = CommandExecutor;

package/dist/config.d.ts

@@ -0,0 +1,8 @@
+interface AgentQConfig {
+    TOKEN?: string;
+    SERVICE_URL?: string;
+}
+export declare function getConfig(): AgentQConfig;
+export declare const getServiceUrl: () => string;
+export declare const getToken: () => string | undefined;
+export {};

package/dist/config.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToken = exports.getServiceUrl = void 0;
+exports.getConfig = getConfig;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const dotenv_1 = require("dotenv");
+(0, dotenv_1.config)();
+function getConfig() {
+    try {
+        const configPath = (0, path_1.join)(process.cwd(), 'agentq.config.json');
+        const configFile = (0, fs_1.readFileSync)(configPath, 'utf-8');
+        return JSON.parse(configFile);
+    }
+    catch (error) {
+        // Config file not found or invalid, continue with env vars
+    }
+    return {
+        TOKEN: process.env.AGENTQ_TOKEN,
+        SERVICE_URL: process.env.AGENTQ_SERVICE_URL,
+    };
+}
+const getServiceUrl = () => {
+    const config = getConfig();
+    return config.SERVICE_URL || 'wss://websocket-ai-automation-test-api.agentq.id';
+};
+exports.getServiceUrl = getServiceUrl;
+const getToken = () => {
+    const config = getConfig();
+    return config.TOKEN;
+};
+exports.getToken = getToken;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export declare function q(userPrompt: string): Promise<void>;
+export declare function initAgentQ(browser: WebdriverIO.Browser): void;
+export declare function handleTestConclusion(testTitle: string, status: 'passed' | 'failed', startTime: number, errorDetails?: string): Promise<void>;

package/dist/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.q = q;
+exports.initAgentQ = initAgentQ;
+exports.handleTestConclusion = handleTestConclusion;
+process.env.DOTENV_CONFIG_QUIET = 'true';
+const wsClient_1 = require("./wsClient");
+const pageContext_1 = require("./pageContext");
+require('dotenv').config({ quiet: true });
+const testResult_1 = require("./testResult");
+const testResult_2 = require("./testResult");
+const stripAnsi = (str) => str.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '');
+async function q(userPrompt) {
+    const browser = pageContext_1.PageContext.getInstance().getBrowser();
+    return wsClient_1.WSClient.getInstance().sendCommand(userPrompt, browser);
+}
+function initAgentQ(browser) {
+    pageContext_1.PageContext.getInstance().setBrowser(browser);
+}
+let cachedAccessToken = null;
+async function handleTestConclusion(testTitle, status, startTime, errorDetails) {
+    const tcId = parseInt(testTitle.split('-')[0]);
+    if (!isNaN(tcId) && process.env.AGENTQ_TESTRUN_ID) {
+        if (!cachedAccessToken) {
+            cachedAccessToken = await (0, testResult_2.getAccessToken)();
+        }
+        const executionTime = (Date.now() - startTime) / 1000;
+        const isPassed = status === 'passed';
+        await (0, testResult_1.exportTestResult)(tcId.toString(), process.env.AGENTQ_TESTRUN_ID, {
+            status: status,
+            actualResult: isPassed ? `Test "${testTitle}" passed successfully`
+                : `Test failed`,
+            executionTime,
+            notes: isPassed ? 'Test completed without errors' : stripAnsi(errorDetails || 'Test failed')
+        });
+        // Note: Artifact upload (screenshots/videos) would need to be handled via WebdriverIO attachments if available
+    }
+}

package/dist/pageContext.d.ts

@@ -0,0 +1,8 @@
+export declare class PageContext {
+    private static instance;
+    private currentBrowser;
+    private constructor();
+    static getInstance(): PageContext;
+    setBrowser(browser: WebdriverIO.Browser): void;
+    getBrowser(): WebdriverIO.Browser;
+}

package/dist/pageContext.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageContext = void 0;
+class PageContext {
+    constructor() {
+        this.currentBrowser = null;
+    }
+    static getInstance() {
+        if (!PageContext.instance) {
+            PageContext.instance = new PageContext();
+        }
+        return PageContext.instance;
+    }
+    setBrowser(browser) {
+        this.currentBrowser = browser;
+    }
+    getBrowser() {
+        if (!this.currentBrowser) {
+            throw new Error('Browser context not set. Make sure to initialize AgentQ with the webdriverio browser object.');
+        }
+        return this.currentBrowser;
+    }
+}
+exports.PageContext = PageContext;

package/dist/pageManager.d.ts

@@ -0,0 +1,8 @@
+export declare class PageManager {
+    private static instance;
+    private currentBrowser;
+    private constructor();
+    static getInstance(): PageManager;
+    setBrowser(browser: WebdriverIO.Browser): void;
+    getBrowser(): WebdriverIO.Browser | null;
+}

package/dist/pageManager.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageManager = void 0;
+class PageManager {
+    constructor() {
+        this.currentBrowser = null;
+    }
+    static getInstance() {
+        if (!PageManager.instance) {
+            PageManager.instance = new PageManager();
+        }
+        return PageManager.instance;
+    }
+    setBrowser(browser) {
+        this.currentBrowser = browser;
+    }
+    getBrowser() {
+        return this.currentBrowser;
+    }
+}
+exports.PageManager = PageManager;

package/dist/pull-testcase.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/pull-testcase.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+// Configuration
+const config = {
+    apiBaseUrl: process.env.AGENTQ_API_URL || 'https://backend-app.agentq.id',
+    projectId: `${process.env.AGENTQ_PROJECT_ID}`,
+    testRunId: `${process.env.AGENTQ_TESTRUN_ID}`,
+    authEndpoint: '/auth/login',
+    authData: {
+        email: `${process.env.AGENTQ_EMAIL}`,
+        password: `${process.env.AGENTQ_PASSWORD}`
+    },
+    outputDir: path_1.default.join(process.cwd(), 'tests')
+};
+// Parse command line arguments more robustly
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let tcId = null;
+    let testRunId = null;
+    for (const arg of args) {
+        const tcIdMatch = arg.match(/--tcid=(\d+)/);
+        if (tcIdMatch) {
+            tcId = tcIdMatch[1];
+        }
+        const testRunIdMatch = arg.match(/--testrunid=([\w-]+)/); // Allow alphanumeric and hyphens
+        if (testRunIdMatch) {
+            testRunId = testRunIdMatch[1];
+        }
+    }
+    // Check environment variables as fallback
+    if (!tcId && process.env.TCID) {
+        tcId = process.env.TCID;
+    }
+    if (!testRunId && process.env.TESTRUNID) {
+        testRunId = process.env.TESTRUNID;
+    }
+    return { tcId, testRunId };
+}
+const { tcId, testRunId } = parseArgs();
+if (!tcId && !testRunId) {
+    console.error('Error: Either --tcid or --testrunid is required.');
+    console.error('Usage for test case:');
+    console.error('  npm run agentq-pull-testcase -- --tcid=<number>');
+    console.error('  or');
+    console.error('  node agentq-pull-testcase.js --tcid=<number>');
+    console.error('Usage for test suite:');
+    console.error('  npm run agentq-pull-testsuite -- --testrunid=<uuid>');
+    console.error('  or');
+    console.error('  node agentq-pull-testcase.js -- --testrunid=<uuid>');
+    process.exit(1);
+}
+// Create the output directory if it doesn't exist
+if (!fs_1.default.existsSync(config.outputDir)) {
+    fs_1.default.mkdirSync(config.outputDir, { recursive: true });
+}
+async function getAccessToken() {
+    try {
+        console.log(`Authenticating with: ${config.apiBaseUrl}${config.authEndpoint}`);
+        const response = await axios_1.default.post(`${config.apiBaseUrl}${config.authEndpoint}`, config.authData, {
+            headers: {
+                'accept': 'application/json',
+                'Content-Type': 'application/json'
+            }
+        });
+        return response.data.access_token;
+    }
+    catch (error) {
+        console.error('Authentication failed:');
+        if (error.response) {
+            console.error(`Status: ${error.response.status}`);
+            console.error(`Response: ${JSON.stringify(error.response.data, null, 2)}`);
+        }
+        else if (error.request) {
+            console.error('No response received during authentication. Check if the server is running.');
+        }
+        else {
+            console.error(`Error during authentication: ${error.message}`);
+        }
+        process.exit(1);
+    }
+}
+async function fetchTestCase(tcId, accessToken) {
+    try {
+        console.log(`Fetching test case from: ${config.apiBaseUrl}/projects/${config.projectId}/test-cases/tcId/${tcId}`);
+        const response = await axios_1.default.get(`${config.apiBaseUrl}/projects/${config.projectId}/test-cases/tcId/${tcId}`, {
+            headers: {
+                'accept': 'application/json',
+                'Authorization': `Bearer ${accessToken}`
+            }
+        });
+        return response.data;
+    }
+    catch (error) {
+        console.error('API request failed:');
+        if (error.response) {
+            console.error(`Status: ${error.response.status}`);
+            console.error(`Response: ${JSON.stringify(error.response.data, null, 2)}`);
+        }
+        else if (error.request) {
+            console.error('No response received from the test case endpoint. Check if the server is running.');
+        }
+        else {
+            console.error(`Error fetching test case: ${error.message}`);
+        }
+        process.exit(1);
+    }
+}
+async function fetchTestSuite(testRunId, accessToken) {
+    try {
+        const apiUrl = `${config.apiBaseUrl}/projects/${config.projectId}/test-runs/${testRunId}/test-results?page=1&limit=10000`;
+        console.log(`Fetching test suite results from: ${apiUrl}`);
+        const response = await axios_1.default.get(apiUrl, {
+            headers: {
+                'accept': 'application/json',
+                'Authorization': `Bearer ${accessToken}`
+            }
+        });
+        return response.data;
+    }
+    catch (error) {
+        console.error(`Failed to fetch test suite results for testRunId: ${testRunId}`);
+        if (error.response) {
+            console.error(`Status: ${error.response.status}`);
+            console.error(`Response: ${JSON.stringify(error.response.data, null, 2)}`);
+        }
+        else if (error.request) {
+            console.error('No response received from the test suite endpoint. Check if the server is running.');
+        }
+        else {
+            console.error(`Error fetching test suite: ${error.message}`);
+        }
+        process.exit(1);
+    }
+}
+function generateTestSuiteSpecFile(testRunId, testResults) {
+    const fileName = `testrun-${testRunId}.spec.ts`;
+    const filePath = path_1.default.join(config.outputDir, fileName);
+    const testsCode = testResults
+        .map(result => {
+        const sanitizedTitle = sanitizeFilename(result.testCase.title);
+        const stepsCode = result.testCase.steps
+            .split('\n')
+            .filter(step => step.trim() !== '')
+            .map(step => `    await q(\`${step}\`);`)
+            .join('\n');
+        return `  it(\`${result.testCase.tcId}-${sanitizedTitle}\`, async () => {
+${stepsCode}
+  });`;
+    })
+        .join('\n\n');
+    const fileContent = `import { q, initAgentQ } from 'agentq-webdriverio';
+
+describe('${testRunId}-testrun', () => {
+  before(() => {
+    initAgentQ(browser);
+  });
+
+${testsCode}
+});
+`;
+    fs_1.default.writeFileSync(filePath, fileContent);
+    console.log(`✅ Created: ${filePath}`);
+    return filePath;
+}
+function sanitizeFilename(title) {
+    // Replace characters that are not allowed in filenames
+    return title
+        .replace(/[/\\?%*:|"<>]/g, '-')
+        .replace(/\s+/g, '-')
+        .substring(0, 100); // Limit length to avoid potential issues
+}
+function generateSpecFile(testCase) {
+    const sanitizedTitle = sanitizeFilename(testCase.title);
+    const fileName = `${sanitizedTitle}.spec.ts`;
+    const filePath = path_1.default.join(config.outputDir, fileName);
+    // Process precondition
+    const preconditionCode = testCase.precondition
+        ? testCase.precondition
+            .split('\n')
+            .filter(line => line.trim() !== '')
+            .map(line => `  await q(\`User is on the ${line.trim()}.\`);`) // Adjusted for clarity
+            .join('\n')
+        : '';
+    // Process steps
+    const stepsCode = testCase.steps
+        .split('\n')
+        .filter(step => step.trim() !== '')
+        .map(step => `  await q(\`${step}\`);`)
+        .join('\n');
+    // Process expected result
+    const expectationCode = testCase.expectation
+        ? testCase.expectation
+            .split('\n')
+            .filter(line => line.trim() !== '')
+            .map(line => `  await q(\`${line.trim()}\`);`)
+            .join('\n')
+        : '';
+    const fileContent = `import { q, initAgentQ } from 'agentq-webdriverio';
+
+describe(\`${testCase.tcId}-${testCase.title}\`, () => {
+  before(() => {
+    initAgentQ(browser);
+  });
+
+  it('Execute test steps', async () => {
+    // Precondition:
+${preconditionCode}
+    // Steps:
+${stepsCode}
+    // Expected Result:
+${expectationCode}
+  });
+});
+`;
+    fs_1.default.writeFileSync(filePath, fileContent);
+    console.log(`✅ Created: ${filePath}`);
+    return filePath;
+}
+// Main execution
+(async () => {
+    if (tcId) {
+        console.log(`🔍 Fetching test case with tcId: ${tcId}`);
+        // Get the access token
+        const accessToken = await getAccessToken();
+        console.log(`🔑 Successfully obtained access token.`);
+        // Fetch the test case using the access token
+        const testCase = await fetchTestCase(tcId, accessToken);
+        console.log(`📄 Found test case: ${testCase.title}`);
+        // Generate the Playwright spec file
+        const filePath = generateSpecFile(testCase);
+        console.log(`\n🚀 Success! Test case converted to Playwright spec file.`);
+    }
+    else if (testRunId) {
+        console.log(`🔍 Fetching test suite results for testRunId: ${testRunId}`);
+        // Get the access token
+        const accessToken = await getAccessToken();
+        console.log(`🔑 Successfully obtained access token.`);
+        // Fetch the test suite results
+        const testSuiteResponse = await fetchTestSuite(testRunId, accessToken);
+        const testResults = testSuiteResponse.results;
+        console.log(`📄 Found ${testResults.length} test cases in test run: ${testRunId}`);
+        // Generate the Playwright spec file for the test suite
+        const filePath = generateTestSuiteSpecFile(testRunId, testResults);
+        console.log(`\n🚀 Success! Test suite converted to Playwright spec file.`);
+    }
+})();

package/dist/testResult.d.ts

@@ -0,0 +1,4 @@
+import { TestResult } from './types';
+export declare function getAccessToken(): Promise<string>;
+export declare function exportTestResult(tcId: string, testRunId: string, result: Partial<TestResult>): Promise<any>;
+export declare function uploadArtifact(testRunId: string, testResultId: string, type: 'screenshot' | 'video', filePath: string): Promise<any>;

package/dist/testResult.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccessToken = getAccessToken;
+exports.exportTestResult = exportTestResult;
+exports.uploadArtifact = uploadArtifact;
+process.env.DOTENV_CONFIG_QUIET = 'true';
+const axios_1 = __importDefault(require("axios"));
+const dotenv = require('dotenv');
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+dotenv.config({ quiet: true });
+// Configuration
+const config = {
+    apiBaseUrl: process.env.AGENTQ_API_URL || 'https://backend-app.agentq.id',
+    projectId: `${process.env.AGENTQ_PROJECT_ID}`,
+    authEndpoint: '/auth/login',
+    authData: {
+        email: `${process.env.AGENTQ_EMAIL}`,
+        password: `${process.env.AGENTQ_PASSWORD}`
+    }
+};
+let cachedToken = null;
+async function getAccessToken() {
+    if (cachedToken) {
+        return cachedToken;
+    }
+    try {
+        console.log(`Authenticating with: ${config.apiBaseUrl}${config.authEndpoint}`);
+        const response = await axios_1.default.post(`${config.apiBaseUrl}${config.authEndpoint}`, config.authData, {
+            headers: {
+                'accept': 'application/json',
+                'Content-Type': 'application/json'
+            }
+        });
+        cachedToken = response.data.access_token;
+        return cachedToken;
+    }
+    catch (error) {
+        console.error('Authentication failed:');
+        if (error.response) {
+            console.error(`Status: ${error.response.status}`);
+            console.error(`Response: ${JSON.stringify(error.response.data, null, 2)}`);
+        }
+        else if (error.request) {
+            console.error('No response received during authentication. Check if the server is running.');
+        }
+        else {
+            console.error(`Error during authentication: ${error.message}`);
+        }
+        process.exit(1);
+    }
+}
+async function exportTestResult(tcId, testRunId, result) {
+    const accessToken = await getAccessToken();
+    const apiUrl = `${config.apiBaseUrl}/projects/${config.projectId}/test-runs/${testRunId}/test-results/tcId/${tcId}`;
+    try {
+        console.log(`Pushing test result to: ${apiUrl}`);
+        const response = await axios_1.default.patch(apiUrl, result, {
+            headers: {
+                'accept': 'application/json',
+                'Authorization': `Bearer ${accessToken}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        console.log('✅ Test result pushed successfully');
+        return response.data;
+    }
+    catch (error) {
+        console.error('Failed to export test result:');
+        if (error.response) {
+            console.error(`Status: ${error.response.status}`);
+            console.error(`Response: ${JSON.stringify(error.response.data, null, 2)}`);
+        }
+        else if (error.request) {
+            console.error('No response received while pushing test result. Check if the server is running.');
+        }
+        else {
+            console.error(`Error pushing test result: ${error.message}`);
+        }
+        throw error;
+    }
+}
+async function uploadArtifact(testRunId, testResultId, type, filePath) {
+    const accessToken = await getAccessToken();
+    const apiUrl = `${config.apiBaseUrl}/projects/${config.projectId}/test-runs/${testRunId}/test-results/${testResultId}/${type}`;
+    if (!fs_1.default.existsSync(filePath)) {
+        console.warn(`⚠️ Artifact file not found: ${filePath}`);
+        return;
+    }
+    try {
+        const formData = new FormData();
+        const fileBuffer = fs_1.default.readFileSync(filePath);
+        const fileName = path_1.default.basename(filePath);
+        const mimetype = type === 'screenshot' ? 'image/png' : 'video/webm';
+        const blob = new Blob([fileBuffer], { type: mimetype });
+        formData.append('file', blob, fileName);
+        console.log(`Uploading ${type} to: ${apiUrl}`);
+        const response = await axios_1.default.post(apiUrl, formData, {
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'Content-Type': 'multipart/form-data'
+            }
+        });
+        console.log(`✅ ${type} uploaded successfully`);
+        return response.data;
+    }
+    catch (error) {
+        console.error(`Failed to upload ${type}:`);
+        if (error.response) {
+            console.error(`Status: ${error.response.status}`);
+            console.error(`Response: ${JSON.stringify(error.response.data, null, 2)}`);
+        }
+        else {
+            console.error(`Error uploading ${type}: ${error.message}`);
+        }
+        // We don't throw here to avoid failing the test just because artifact upload failed
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,49 @@
+export interface AICommand {
+    action: 'fill' | 'click' | 'visit' | 'goto' | 'navigate' | 'open' | 'select' | 'check' | 'uncheck' | 'type' | 'wait' | 'assertVisible' | 'assertNotVisible' | 'assertEqual' | 'assertContain';
+    target: string;
+    value?: string | number | {
+        value?: string;
+        label?: string;
+        index?: number;
+    } | string[];
+}
+export interface WSQueueItem {
+    resolve: (value: void) => void;
+    reject: (reason: any) => void;
+    command: () => Promise<void>;
+}
+export interface TestResult {
+    status: 'passed' | 'failed' | 'skipped';
+    actualResult: string;
+    executionTime: number;
+    notes: string;
+}
+export interface TestResultResponse {
+    id: string;
+    testRunId: string;
+    testCaseId: string;
+    status: string;
+    actualResult: string;
+    executionTime: number;
+    notes: string;
+    screenshotUrl: string | null;
+    videoUrl: string | null;
+    createdAt: string;
+    updatedAt: string;
+    testCase: {
+        id: string;
+        tcId: number;
+        title: string;
+        precondition: string;
+        steps: string;
+        expectation: string;
+        priority: string;
+        type: string;
+        platform: string;
+        testCaseType: string;
+        projectId: string;
+        folderId: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wsClient.d.ts

@@ -0,0 +1,13 @@
+export declare class WSClient {
+    private static instance;
+    private ws;
+    private connected;
+    private token;
+    private commandQueue;
+    private constructor();
+    static getInstance(): WSClient;
+    private connect;
+    private setupWebSocket;
+    private processQueue;
+    sendCommand(userPrompt: string, browser: WebdriverIO.Browser): Promise<void>;
+}

package/dist/wsClient.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WSClient = void 0;
+const ws_1 = __importDefault(require("ws"));
+const config_1 = require("./config");
+const commandExecutor_1 = require("./commandExecutor");
+class WSClient {
+    constructor() {
+        this.ws = null;
+        this.connected = false;
+        this.commandQueue = [];
+        this.token = (0, config_1.getToken)() || '';
+        if (!this.token) {
+            throw new Error('AgentQ token is required. Please provide it via agentq.config.json or AGENTQ_TOKEN environment variable.');
+        }
+        this.connect();
+    }
+    static getInstance() {
+        if (!WSClient.instance) {
+            WSClient.instance = new WSClient();
+        }
+        return WSClient.instance;
+    }
+    connect() {
+        if (this.ws)
+            return;
+        this.ws = new ws_1.default((0, config_1.getServiceUrl)());
+        this.setupWebSocket();
+    }
+    setupWebSocket() {
+        if (!this.ws)
+            return;
+        this.ws.on('open', () => {
+            this.connected = true;
+            this.processQueue();
+        });
+        this.ws.on('close', () => {
+            this.connected = false;
+            this.ws = null;
+            setTimeout(() => this.connect(), 5000);
+        });
+        this.ws.on('error', (error) => {
+            console.error('WebSocket error:', error);
+        });
+    }
+    async processQueue() {
+        while (this.commandQueue.length > 0) {
+            const item = this.commandQueue.shift();
+            if (item) {
+                try {
+                    await item.command();
+                    item.resolve();
+                }
+                catch (error) {
+                    item.reject(error);
+                }
+            }
+        }
+    }
+    async sendCommand(userPrompt, browser) {
+        return new Promise((resolve, reject) => {
+            const command = async () => {
+                if (!this.ws) {
+                    throw new Error('WebSocket connection not available');
+                }
+                const pageSource = await browser.getPageSource();
+                return new Promise((wsResolve, wsReject) => {
+                    const messageHandler = async (message) => {
+                        try {
+                            const response = JSON.parse(message.toString());
+                            if (response.type === 'error') {
+                                wsReject(new Error(response.message));
+                                return;
+                            }
+                            if (response.command) {
+                                await commandExecutor_1.CommandExecutor.execute(response.command, browser);
+                                wsResolve();
+                            }
+                            else {
+                                wsReject(new Error('Invalid command received'));
+                            }
+                            this.ws?.removeListener('message', messageHandler);
+                        }
+                        catch (error) {
+                            wsReject(error);
+                        }
+                    };
+                    this.ws?.on('message', messageHandler);
+                    this.ws?.send(JSON.stringify({
+                        type: 'command',
+                        prompt: userPrompt,
+                        pageSource,
+                        token: this.token,
+                    }));
+                });
+            };
+            if (this.connected) {
+                command().then(resolve).catch(reject);
+            }
+            else {
+                this.commandQueue.push({ resolve, reject, command });
+            }
+        });
+    }
+}
+exports.WSClient = WSClient;

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "agentq-webdriverio",
+  "version": "1.0.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "agentq-pull-testcase": "./dist/pull-testcase.js",
+    "agentq-pull-testsuite": "./dist/pull-testcase.js"
+  },
+  "author": {
+    "name": "agentq.id",
+    "email": "support@agentq.id"
+  },
+  "license": "MIT",
+  "description": "",
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "agentq-pull-testcase": "node ./dist/pull-testcase.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agentq-ai/agentq-webdriverio.git"
+  },
+  "keywords": [],
+  "type": "commonjs",
+  "bugs": {
+    "url": "https://github.com/agentq-ai/agentq-webdriverio/issues"
+  },
+  "homepage": "https://github.com/agentq-ai/agentq-webdriverio#readme",
+  "dependencies": {
+    "webdriverio": "^9.0.0",
+    "axios": "^1.7.2",
+    "dotenv": "^16.4.5",
+    "ws": "^8.17.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.2",
+    "@types/ws": "^8.5.10",
+    "@wdio/cli": "^9.0.0",
+    "@wdio/globals": "^9.0.0",
+    "typescript": "^5.4.5"
+  }
+}