@xenon-device-management/xenon 1.1.0

package/schema.json

@@ -0,0 +1,348 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema",
+    "additionalProperties": false,
+    "description": "Appium configuration schema for the Xenon plugin.",
+    "properties": {
+        "platform": {
+            "type": "string",
+            "enum": [
+                "ios",
+                "android",
+                "both"
+            ],
+            "default": "both"
+        },
+        "androidDeviceType": {
+            "title": "DeviceTypeToInclude",
+            "type": "string",
+            "enum": [
+                "both",
+                "real",
+                "simulated"
+            ],
+            "default": "both"
+        },
+        "simulators": {
+            "type": "array",
+            "items": {
+                "$ref": "#/definitions/SimulatorConfig"
+            },
+            "default": []
+        },
+        "iosDeviceType": {
+            "title": "DeviceTypeToInclude1",
+            "type": "string",
+            "enum": [
+                "both",
+                "real",
+                "simulated"
+            ],
+            "default": "both"
+        },
+        "hub": {
+            "type": "string"
+        },
+        "remoteMachineProxyIP": {
+            "type": "string"
+        },
+        "adbRemote": {
+            "type": "array",
+            "items": {
+                "type": "string"
+            },
+            "default": []
+        },
+        "skipChromeDownload": {
+            "type": "boolean",
+            "default": true
+        },
+        "maxSessions": {
+            "type": "number",
+            "default": 8
+        },
+        "cloud": {
+            "type": "object",
+            "description": "Cloud configuration object. See CloudConfig interface for details."
+        },
+        "derivedDataPath": {
+            "title": "IDerivedDataPath",
+            "type": "object",
+            "additionalProperties": {
+                "type": "string"
+            },
+            "description": "Map of derived data paths for iOS simulators/devices."
+        },
+        "emulators": {
+            "type": "array",
+            "items": {
+                "$ref": "#/definitions/EmulatorConfig"
+            },
+            "default": []
+        },
+        "proxy": {
+            "type": "object",
+            "description": "Proxy configuration object. See AxiosProxy interface for details."
+        },
+        "deviceAvailabilityTimeoutMs": {
+            "type": "number",
+            "default": 300000
+        },
+        "deviceAvailabilityQueryIntervalMs": {
+            "type": "number",
+            "default": 10000
+        },
+        "sendNodeDevicesToHubIntervalMs": {
+            "type": "number",
+            "default": 30000
+        },
+        "checkStaleDevicesIntervalMs": {
+            "type": "number",
+            "default": 30000
+        },
+        "checkBlockedDevicesIntervalMs": {
+            "type": "number",
+            "default": 30000
+        },
+        "newCommandTimeoutSec": {
+            "type": "number",
+            "default": 60
+        },
+        "bindHostOrIp": {
+            "type": "string",
+            "default": "127.0.0.1"
+        },
+        "enableDashboard": {
+            "type": "boolean",
+            "default": false
+        },
+        "bootedSimulators": {
+            "type": "boolean",
+            "default": false
+        },
+        "removeDevicesFromDatabaseBeforeRunningThePlugin": {
+            "type": "boolean",
+            "default": false
+        },
+        "healthCheckIntervalMs": {
+            "type": "number",
+            "default": 86400000
+        },
+        "healthCheckSchedule": {
+            "type": "string"
+        },
+        "databaseProvider": {
+            "type": "string",
+            "enum": [
+                "sqlite",
+                "postgresql"
+            ]
+        },
+        "databaseUrl": {
+            "type": "string"
+        },
+        "aiProvider": {
+            "type": "string",
+            "enum": [
+                "gemini",
+                "openai",
+                "anthropic",
+                "ollama"
+            ]
+        },
+        "aiModel": {
+            "type": "string"
+        },
+        "aiBaseUrl": {
+            "type": "string"
+        },
+        "geminiApiKey": {
+            "type": "string"
+        },
+        "openaiApiKey": {
+            "type": "string"
+        },
+        "anthropicApiKey": {
+            "type": "string"
+        },
+        "enableSelfHealing": {
+            "type": "boolean",
+            "default": true
+        },
+        "buildCleanupDays": {
+            "type": "number",
+            "default": 30
+        },
+        "buildCleanupMaxCount": {
+            "type": "number",
+            "default": 100
+        },
+        "buildCleanupSchedule": {
+            "type": "string",
+            "default": "0 0 * * *"
+        },
+        "deleteBuildAssets": {
+            "type": "boolean",
+            "default": true
+        },
+        "sessionHeartbeatIntervalMs": {
+            "type": "number",
+            "default": 30000
+        },
+        "enableJsonLogging": {
+            "type": "boolean",
+            "default": false
+        },
+        "tlsRejectUnauthorized": {
+            "type": "boolean",
+            "default": true,
+            "description": "Whether to verify TLS certificates for internal outgoing requests. Default is true. Set to false only for dev/test."
+        }
+    },
+    "required": [
+        "platform",
+        "androidDeviceType",
+        "iosDeviceType",
+        "skipChromeDownload",
+        "maxSessions",
+        "deviceAvailabilityTimeoutMs",
+        "deviceAvailabilityQueryIntervalMs",
+        "sendNodeDevicesToHubIntervalMs",
+        "checkStaleDevicesIntervalMs",
+        "checkBlockedDevicesIntervalMs",
+        "newCommandTimeoutSec",
+        "bindHostOrIp",
+        "enableDashboard",
+        "bootedSimulators",
+        "removeDevicesFromDatabaseBeforeRunningThePlugin",
+        "healthCheckIntervalMs",
+        "enableSelfHealing",
+        "buildCleanupDays",
+        "buildCleanupMaxCount",
+        "buildCleanupSchedule",
+        "deleteBuildAssets",
+        "sessionHeartbeatIntervalMs",
+        "enableJsonLogging"
+    ],
+    "title": "IPluginArgs",
+    "type": "object",
+    "definitions": {
+        "AxiosProxy": {
+            "type": "object",
+            "title": "AxiosProxy",
+            "properties": {
+                "host": {
+                    "type": "string"
+                },
+                "port": {
+                    "type": "integer"
+                },
+                "protocol": {
+                    "type": "string",
+                    "enum": [
+                        "http",
+                        "https"
+                    ]
+                },
+                "auth": {
+                    "type": "object"
+                }
+            },
+            "additionalProperties": true,
+            "description": "Proxy configuration object. Contains 'host', 'port', 'auth', 'protocol'."
+        },
+        "CloudConfig": {
+            "type": "object",
+            "title": "CloudConfig",
+            "additionalProperties": false,
+            "description": "Cloud configuration object. Should be provided via config file.",
+            "properties": {
+                "cloudName": {
+                    "type": "string",
+                    "description": "Name of the cloud provider (e.g. browserstack, saucelabs, pcloudy, lambdatest)"
+                },
+                "url": {
+                    "type": "string",
+                    "format": "uri",
+                    "description": "URL of the cloud provider hub"
+                },
+                "apiKey": {
+                    "type": "string",
+                    "description": "API Key for the cloud provider"
+                },
+                "apiUrl": {
+                    "type": "string",
+                    "format": "uri",
+                    "description": "API URL for the cloud provider"
+                },
+                "devices": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/CloudDevice"
+                    }
+                }
+            },
+            "required": [
+                "cloudName",
+                "url",
+                "apiKey",
+                "devices"
+            ]
+        },
+        "CloudDevice": {
+            "type": "object",
+            "title": "CloudDevice",
+            "additionalProperties": true,
+            "description": "Device configuration object",
+            "properties": {
+                "deviceName": {
+                    "type": "string"
+                },
+                "platform": {
+                    "type": "string"
+                },
+                "os_version": {
+                    "type": "string"
+                },
+                "platformVersion": {
+                    "type": "string"
+                },
+                "pCloudy_DeviceManufacturer": {
+                    "type": "string"
+                },
+                "pCloudy_DeviceVersion": {
+                    "type": "string"
+                }
+            }
+        },
+        "SimulatorConfig": {
+            "type": "object",
+            "title": "SimulatorConfig",
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "sdk": {
+                    "type": "string"
+                }
+            },
+            "required": [
+                "name",
+                "sdk"
+            ],
+            "additionalProperties": true
+        },
+        "EmulatorConfig": {
+            "type": "object",
+            "title": "EmulatorConfig",
+            "properties": {
+                "avdName": {
+                    "type": "string"
+                }
+            },
+            "required": [
+                "avdName"
+            ],
+            "additionalProperties": true
+        }
+    }
+}

package/scripts/build-xenon.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+set -e
+
+# Xenon Build & Asset Sync
+# Rebuilds the frontend and copies artifacts to the plugin delivery directory.
+
+echo "🚀 Starting Xenon Production Build..."
+
+# 1. Install & Build Web Frontend
+cd web
+echo "📦 Installing web dependencies..."
+npm install
+echo "🏗 Building web dashboard..."
+npm run build
+cd ..
+
+# 2. Sync Artifacts
+echo "🔄 Syncing build artifacts..."
+rm -rf src/public
+mkdir -p src/public
+
+# Using absolute-ish path for robustness in CI
+if [ -d "web/build" ] && [ "$(ls -A web/build)" ]; then
+  echo "📦 Copying artifacts from web/build to src/public..."
+  cp -R web/build/. src/public/
+  echo "✅ Xenon build complete."
+else
+  echo "❌ Error: web/build directory not found or empty. Frontend build failed?"
+  ls -la web/ || true
+  ls -la web/build/ || true
+  exit 1
+fi

package/scripts/dev/debug-gemini.ts

@@ -0,0 +1,44 @@
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import * as dotenv from 'dotenv';
+dotenv.config();
+
+async function debugGemini() {
+  const apiKey = process.env.GEMINI_API_KEY;
+  if (!apiKey) {
+    console.error('No GEMINI_API_KEY found in .env');
+    return;
+  }
+
+  console.log('Testing with API Key (truncated):', apiKey.substring(0, 5) + '...');
+
+  try {
+    const genAI = new GoogleGenerativeAI(apiKey);
+
+    // Try v1 first
+    console.log('\n--- Testing v1 Endpoint ---');
+    try {
+      const modelV1 = genAI.getGenerativeModel({ model: 'gemini-1.5-flash' }, { apiVersion: 'v1' });
+      const resultV1 = await modelV1.generateContent('Hi');
+      console.log('v1 Success:', resultV1.response.text());
+    } catch (e: any) {
+      console.error('v1 Failed:', e.message);
+    }
+
+    // Try v1beta
+    console.log('\n--- Testing v1beta Endpoint ---');
+    try {
+      const modelBeta = genAI.getGenerativeModel(
+        { model: 'gemini-1.5-flash' },
+        { apiVersion: 'v1beta' },
+      );
+      const resultBeta = await modelBeta.generateContent('Hi');
+      console.log('v1beta Success:', resultBeta.response.text());
+    } catch (e: any) {
+      console.error('v1beta Failed:', e.message);
+    }
+  } catch (err: any) {
+    console.error('Debug failed:', err.message);
+  }
+}
+
+debugGemini();

package/scripts/generate-types-from-schema.js

@@ -0,0 +1,86 @@
+const { compileFromFile } = require('json-schema-to-typescript');
+const fs = require('fs');
+const path = require('path');
+
+async function generate() {
+    const schemaPath = path.join(__dirname, '../schema.json');
+    const outputPath = path.join(__dirname, '../src/interfaces/IPluginArgs.ts');
+
+    console.log(`Generating types from ${schemaPath}...`);
+
+    try {
+        const schema = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
+
+        // Inject strict definitions into properties for type generation only.
+        // This keeps the runtime schema.json simple and compatible with Appium's CLI flattener.
+        schema.properties.cloud = { '$ref': '#/definitions/CloudConfig' };
+        schema.properties.proxy = { '$ref': '#/definitions/AxiosProxy' };
+
+        const { compile } = require('json-schema-to-typescript');
+        const ts = await compile(schema, 'IPluginArgs', {
+            bannerComment: `/* eslint-disable */
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run "npm run build:schema" to regenerate this file.
+ */
+import ip from 'ip';`,
+            style: {
+                singleQuote: true,
+            },
+        });
+
+        const defaultArgs = `
+export const DefaultPluginArgs: IPluginArgs = {
+  platform: 'both',
+  iosDeviceType: 'both',
+  androidDeviceType: 'both',
+  skipChromeDownload: true,
+  hub: undefined,
+  maxSessions: 8,
+  derivedDataPath: undefined,
+  adbRemote: [],
+  remoteMachineProxyIP: undefined,
+  proxy: undefined,
+  emulators: [],
+  simulators: [],
+  deviceAvailabilityTimeoutMs: 300000,
+  deviceAvailabilityQueryIntervalMs: 10000,
+  sendNodeDevicesToHubIntervalMs: 30000,
+  checkStaleDevicesIntervalMs: 30000,
+  checkBlockedDevicesIntervalMs: 30000,
+  newCommandTimeoutSec: 60,
+  cloud: undefined,
+  bindHostOrIp: ip.address(),
+  enableDashboard: false,
+  bootedSimulators: false,
+  healthCheckIntervalMs: 86400000,
+  healthCheckSchedule: undefined,
+  removeDevicesFromDatabaseBeforeRunningThePlugin: false,
+  databaseProvider: undefined,
+  databaseUrl: undefined,
+  aiProvider: undefined,
+  aiModel: undefined,
+  aiBaseUrl: undefined,
+  geminiApiKey: undefined,
+  openaiApiKey: undefined,
+  anthropicApiKey: undefined,
+  enableSelfHealing: true,
+  buildCleanupDays: 30,
+  buildCleanupMaxCount: 100,
+  buildCleanupSchedule: '0 0 * * *',
+  deleteBuildAssets: true,
+  sessionHeartbeatIntervalMs: 30000,
+  enableJsonLogging: false,
+};
+`;
+
+        fs.writeFileSync(outputPath, ts + defaultArgs);
+        console.log(`Successfully generated types at ${outputPath}`);
+    } catch (e) {
+        console.error('Error generating types:', e);
+        process.exit(1);
+    }
+}
+
+generate();

package/scripts/install-compatible-driver.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const semver = require('semver');
+
+try {
+  console.log('Detecting Appium server version...');
+  // Prefer local appium CLI if available, else fall back to global 'appium'
+  const localAppium = path.resolve(__dirname, '..', 'node_modules', '.bin', 'appium');
+  const appiumCmd = fs.existsSync(localAppium) ? localAppium : 'appium';
+  const versionRaw = execSync(`${appiumCmd} --version`, { encoding: 'utf8' }).trim();
+  // appium --version returns something like "2.4.1" or "3.0.0-rc.2"
+  const version = semver.coerce(versionRaw);
+  if (!version) {
+    console.error('Unable to parse Appium version:', versionRaw);
+    process.exit(1);
+  }
+
+  const major = version.major;
+  console.log('Appium server version detected:', version.raw);
+
+  let driverToInstall = 'xcuitest@5.14.0';
+  if (major >= 3) {
+    console.log('Appium 3.x detected; installing latest compatible xcuitest driver');
+    driverToInstall = 'xcuitest';
+  } else {
+    console.log(
+      'Appium 2.x detected; installing xcuitest driver compatible with Appium 2.4.1 (5.14.0)',
+    );
+  }
+
+  const cmd = `${appiumCmd} driver install ${driverToInstall}`;
+  console.log('Running:', cmd);
+  execSync(cmd, { stdio: 'inherit' });
+} catch (err) {
+  console.error('Failed to install driver:', err.message);
+  process.exit(1);
+}