farm-orchestrator 1.0.1

package/dist/src/scripts/db-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function createDatabase(): Promise<void>;
+export declare function runMigrations(): Promise<void>;

package/dist/src/scripts/db-utils.js

@@ -0,0 +1,191 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDatabase = createDatabase;
+exports.runMigrations = runMigrations;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const pg_1 = require("pg");
+const dbConfig = {
+    host: process.env.DB_HOST || 'localhost',
+    port: parseInt(process.env.DB_PORT || '5432', 10),
+    user: process.env.DB_USER || 'postgres',
+    password: process.env.DB_PASSWORD || '',
+};
+const dbName = process.env.DB_NAME || 'device_farm';
+async function createDatabase() {
+    // Try connecting to different default databases to create the target database
+    const defaultDatabases = ['postgres', 'template1'];
+    let client = null;
+    let connected = false;
+    console.log(`Attempting to connect to PostgreSQL at ${dbConfig.host}:${dbConfig.port}...`);
+    for (const defaultDb of defaultDatabases) {
+        try {
+            client = new pg_1.Client({
+                ...dbConfig,
+                database: defaultDb,
+            });
+            await client.connect();
+            console.log(`Connected to PostgreSQL as ${dbConfig.user} (via ${defaultDb})`);
+            connected = true;
+            break;
+        }
+        catch (error) {
+            if (client) {
+                try {
+                    await client.end();
+                }
+                catch (e) {
+                    // Ignore cleanup errors
+                }
+            }
+            // Try next database
+            continue;
+        }
+    }
+    if (!connected) {
+        console.error('Error: Could not connect to PostgreSQL. Make sure PostgreSQL is running.');
+        throw new Error('Could not connect to PostgreSQL');
+    }
+    if (!client) {
+        throw new Error('Client is null despite connected being true');
+    }
+    try {
+        // Check if database exists
+        const result = await client.query(`SELECT 1 FROM pg_database WHERE datname = $1`, [dbName]);
+        if (result.rows.length > 0) {
+            console.log(`Database "${dbName}" already exists.`);
+            await client.end();
+            return;
+        }
+        // Create the database
+        // Note: Parameterized queries cannot be used for database names in CREATE DATABASE
+        // We sanitize by using double quotes, assuming dbName comes from trusted env or config
+        await client.query(`CREATE DATABASE "${dbName}"`);
+        console.log(`Database "${dbName}" created successfully.`);
+        await client.end();
+    }
+    catch (error) {
+        if (error.code === '42P04') {
+            // Database already exists (race condition)
+            console.log(`Database "${dbName}" already exists.`);
+        }
+        else {
+            console.error('Error creating database:', error.message);
+            if (client) {
+                await client.end();
+            }
+            throw error;
+        }
+    }
+}
+async function runMigrations() {
+    console.log('Running database migrations...');
+    // Find sequelize-cli executable
+    let sequelizeBin;
+    let useNode = true;
+    try {
+        // Try to resolve from node_modules
+        const sequelizePkg = require.resolve('sequelize-cli/package.json');
+        const pkgRoot = path_1.default.dirname(sequelizePkg);
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const pkgJson = require(sequelizePkg);
+        const binPath = typeof pkgJson.bin === 'string' ? pkgJson.bin : pkgJson.bin['sequelize'];
+        sequelizeBin = path_1.default.join(pkgRoot, binPath);
+        useNode = true;
+    }
+    catch (error) {
+        console.warn('Could not resolve sequelize-cli from dependencies, trying global or relative path...');
+        // Try to find in node_modules/.bin (in current dir and up the tree)
+        const possiblePaths = [
+            path_1.default.resolve(process.cwd(), 'node_modules', '.bin', 'sequelize-cli'),
+            path_1.default.resolve(process.cwd(), '..', 'node_modules', '.bin', 'sequelize-cli'), // parent dir
+            path_1.default.resolve(process.cwd(), '..', '..', 'node_modules', '.bin', 'sequelize-cli'), // repo root (if packages/hub)
+        ];
+        const foundBin = possiblePaths.find(p => fs_1.default.existsSync(p));
+        if (foundBin) {
+            console.log(`Found sequelize-cli at: ${foundBin}`);
+            sequelizeBin = foundBin;
+            useNode = false; // Executable script/symlink
+        }
+        else {
+            console.warn('Could not find sequelize-cli in common locations, falling back to PATH');
+            sequelizeBin = 'sequelize-cli'; // Fallback to PATH
+            useNode = false;
+        }
+    }
+    // Find config file
+    // In development: src/config/sequelize-cli.js
+    // In production (bundled): might be tricky.
+    // But we know where the source is relative to CWD usually.
+    // If running from node_modules/@device-farm/hub/dist/src/bundle.js
+    // process.cwd() is user's project root.
+    // We need to point to the config file inside the package.
+    // Assuming bundle structure:
+    // dist/src/bundle.js
+    // src/config/sequelize-cli.js (if copied)
+    // OR we can generate a temporary config file.
+    // Let's rely on .sequelizerc if it exists in the package root.
+    // But package root relative to bundle.js is ../..
+    const currentDir = __dirname; // dist/src (if bundled) or src/scripts (if ts-node)
+    // Helper to find file recursively up or in common locations
+    const findFile = (searchPaths) => {
+        for (const p of searchPaths) {
+            if (fs_1.default.existsSync(p))
+                return p;
+        }
+        return null;
+    };
+    // Possible locations for sequelize config
+    // 1. Inside built output: dist/src/config/sequelize-cli.js
+    // 2. Inside source: src/config/sequelize-cli.js
+    const configPath = findFile([
+        path_1.default.resolve(currentDir, '../config/sequelize-cli.js'), // dist/src/config/sequelize-cli.js
+        path_1.default.resolve(currentDir, '../../src/config/sequelize-cli.js'), // src/config/sequelize-cli.js (from scripts)
+        path_1.default.resolve(process.cwd(), 'node_modules/@device-farm/hub/src/config/sequelize-cli.js'),
+    ]);
+    // Possible locations for migrations
+    const migrationsPath = findFile([
+        path_1.default.resolve(currentDir, '../../migrations'), // dist/src/../../migrations -> dist/migrations ?? No.
+        // If we are in dist/src, ../.. is dist. ../../../ is root.
+        // If migrations are in root/migrations.
+        path_1.default.resolve(currentDir, '../../../migrations'), // from dist/src
+        path_1.default.resolve(currentDir, '../../migrations'), // from src/scripts
+        path_1.default.resolve(process.cwd(), 'node_modules/@device-farm/hub/migrations'),
+    ]);
+    if (!configPath) {
+        throw new Error('Could not find sequelize-cli.js config file');
+    }
+    if (!migrationsPath) {
+        throw new Error('Could not find migrations directory');
+    }
+    console.log(`Using config: ${configPath}`);
+    console.log(`Using migrations: ${migrationsPath}`);
+    return new Promise((resolve, reject) => {
+        const args = ['db:migrate', `--config=${configPath}`, `--migrations-path=${migrationsPath}`];
+        const command = useNode ? process.execPath : sequelizeBin;
+        const commandArgs = useNode ? [sequelizeBin, ...args] : args;
+        console.log(`Executing: ${command} ${commandArgs.join(' ')}`);
+        const child = (0, child_process_1.spawn)(command, commandArgs, {
+            stdio: 'inherit',
+            env: process.env,
+        });
+        child.on('close', code => {
+            if (code === 0) {
+                console.log('Migrations completed successfully.');
+                resolve();
+            }
+            else {
+                console.error(`Migrations failed with code ${code}`);
+                reject(new Error(`Migrations failed with code ${code}`));
+            }
+        });
+        child.on('error', err => {
+            console.error('Failed to start sequelize-cli:', err);
+            reject(err);
+        });
+    });
+}

package/dist/src/scripts/prepare-wda.d.ts

@@ -0,0 +1,16 @@
+/**
+ * WebDriverAgent (WDA) Preparation Script
+ *
+ * This script builds, signs, and packages WebDriverAgent for iOS devices.
+ * It can be run as a CLI command: `hub prepare-wda`
+ *
+ * Options:
+ *   --mobile-provisioning-file, -m  Path to the mobile provisioning file
+ *   --wda-project-path, -p          Path to WebDriverAgent xcode project
+ *   --platform                      Platform type: ios, tvos, or both (default: ios)
+ */
+import { PrepareWdaOptions } from '../config/hub.config';
+/**
+ * Main function to prepare WDA
+ */
+export declare function prepareWda(options: PrepareWdaOptions): Promise<void>;