@tvlabs/wdio-service 0.1.4 → 0.1.6

package/src/channels/base.ts

@@ -0,0 +1,110 @@
+import { WebSocket } from 'ws';
+import { Socket, type Channel } from 'phoenix';
+import { SevereServiceError } from 'webdriverio';
+import { Logger } from '../logger.js';
+import { getServiceInfo } from '../utils.js';
+
+import type { TVLabsSocketParams, LogLevel } from '../types.js';
+import type { PhoenixChannelJoinResponse } from '../phoenix.js';
+
+export abstract class BaseChannel {
+  protected socket: Socket;
+  protected log: Logger;
+
+  constructor(
+    protected endpoint: string,
+    protected maxReconnectRetries: number,
+    protected key: string,
+    protected logLevel: LogLevel = 'info',
+    loggerName: string,
+  ) {
+    this.log = new Logger(loggerName, this.logLevel);
+
+    this.socket = new Socket(this.endpoint, {
+      transport: WebSocket,
+      params: this.params(),
+      reconnectAfterMs: this.reconnectAfterMs.bind(this),
+    });
+
+    this.socket.onError((...args) =>
+      BaseChannel.logSocketError(this.log, ...args),
+    );
+  }
+
+  abstract connect(): Promise<void>;
+  abstract disconnect(): Promise<void>;
+
+  protected async join(topic: Channel): Promise<void> {
+    return new Promise((res, rej) => {
+      topic
+        .join()
+        .receive('ok', (_resp: PhoenixChannelJoinResponse) => {
+          res();
+        })
+        .receive('error', ({ response }: PhoenixChannelJoinResponse) => {
+          rej('Failed to join topic: ' + response);
+        })
+        .receive('timeout', () => {
+          rej('timeout');
+        });
+    });
+  }
+
+  protected async push<T>(
+    topic: Channel,
+    event: string,
+    payload: object,
+  ): Promise<T> {
+    return new Promise((res, rej) => {
+      topic
+        .push(event, payload)
+        .receive('ok', (msg: T) => {
+          res(msg);
+        })
+        .receive('error', (reason: string) => {
+          rej(reason);
+        })
+        .receive('timeout', () => {
+          rej('timeout');
+        });
+    });
+  }
+
+  private params(): TVLabsSocketParams {
+    const serviceInfo = getServiceInfo();
+
+    this.log.debug('Info:', serviceInfo);
+
+    return {
+      ...serviceInfo,
+      api_key: this.key,
+    };
+  }
+
+  private reconnectAfterMs(tries: number) {
+    if (tries > this.maxReconnectRetries) {
+      throw new SevereServiceError(
+        'Could not connect to TV Labs, please check your connection.',
+      );
+    }
+
+    const wait = [0, 1000, 3000, 5000][tries] || 10000;
+
+    this.log.info(
+      `[${tries}/${this.maxReconnectRetries}] Waiting ${wait}ms before re-attempting to connect...`,
+    );
+
+    return wait;
+  }
+
+  private static logSocketError(
+    log: Logger,
+    event: ErrorEvent,
+    _transport: new (endpoint: string) => object,
+    _establishedConnections: number,
+  ) {
+    const error = event.error;
+
+    log.error('Socket error:', error || event);
+  }
+}

package/src/channels/build.ts

@@ -0,0 +1,174 @@
+import { type Channel } from 'phoenix';
+import { SevereServiceError } from 'webdriverio';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+
+import { BaseChannel } from './base.js';
+
+import type {
+  TVLabsExtractBuildInfoResponse,
+  TVLabsRequestUploadUrlResponse,
+  TVLabsBuildMetadata,
+  LogLevel,
+} from '../types.js';
+
+export class BuildChannel extends BaseChannel {
+  private lobbyTopic: Channel;
+
+  constructor(
+    endpoint: string,
+    maxReconnectRetries: number,
+    key: string,
+    logLevel: LogLevel = 'info',
+  ) {
+    super(
+      endpoint,
+      maxReconnectRetries,
+      key,
+      logLevel,
+      '@tvlabs/build-channel',
+    );
+    this.lobbyTopic = this.socket.channel('upload:lobby');
+  }
+
+  async disconnect(): Promise<void> {
+    return new Promise((res, _rej) => {
+      this.lobbyTopic.leave();
+      this.socket.disconnect(() => res());
+    });
+  }
+
+  async connect(): Promise<void> {
+    try {
+      this.log.debug('Connecting to build channel...');
+
+      this.socket.connect();
+
+      await this.join(this.lobbyTopic);
+
+      this.log.debug('Connected to build channel!');
+    } catch (error) {
+      this.log.error('Error connecting to build channel:', error);
+      throw new SevereServiceError(
+        'Could not connect to build channel, please check your connection.',
+      );
+    }
+  }
+
+  async uploadBuild(buildPath: string, appSlug?: string): Promise<string> {
+    const metadata = await this.getFileMetadata(buildPath);
+
+    this.log.info(
+      `Requesting upload for build ${metadata.filename} (${metadata.type}, ${metadata.size} bytes)`,
+    );
+
+    const { url, build_id } = await this.requestUploadUrl(metadata, appSlug);
+
+    this.log.info('Uploading build...');
+
+    await this.uploadToUrl(url, buildPath, metadata);
+
+    const { application_id } = await this.extractBuildInfo();
+
+    this.log.info(`Build "${application_id}" processed successfully`);
+
+    return build_id;
+  }
+
+  private async requestUploadUrl(
+    metadata: TVLabsBuildMetadata,
+    appSlug: string | undefined,
+  ) {
+    try {
+      return await this.push<TVLabsRequestUploadUrlResponse>(
+        this.lobbyTopic,
+        'request_upload_url',
+        { metadata, application_slug: appSlug },
+      );
+    } catch (error) {
+      this.log.error('Error requesting upload URL:', error);
+      throw error;
+    }
+  }
+
+  private async uploadToUrl(
+    url: string,
+    filePath: string,
+    metadata: TVLabsBuildMetadata,
+  ): Promise<void> {
+    try {
+      const response = await fetch(url, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': metadata.type,
+          'Content-Length': String(metadata.size),
+        },
+        // @ts-expect-error - FIXME: fetch types are incorrect
+        body: fs.createReadStream(filePath),
+        duplex: 'half',
+      });
+
+      if (!response.ok) {
+        throw new SevereServiceError(
+          `Failed to upload build to storage, got ${response.status}`,
+        );
+      }
+
+      this.log.info('Upload complete');
+    } catch (error) {
+      this.log.error('Error uploading build:', error);
+      throw error;
+    }
+  }
+
+  private async extractBuildInfo() {
+    this.log.info('Processing uploaded build...');
+
+    try {
+      return await this.push<TVLabsExtractBuildInfoResponse>(
+        this.lobbyTopic,
+        'extract_build_info',
+        {},
+      );
+    } catch (error) {
+      this.log.error('Error processing build:', error);
+      throw error;
+    }
+  }
+
+  private async getFileMetadata(
+    buildPath: string,
+  ): Promise<TVLabsBuildMetadata> {
+    const filename = path.basename(buildPath);
+    const size = fs.statSync(buildPath).size;
+    const type = this.detectMimeType(filename);
+    const sha256 = await this.computeSha256(buildPath);
+
+    return { filename, type, size, sha256 };
+  }
+
+  private async computeSha256(buildPath: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const hash = crypto.createHash('sha256');
+      const stream = fs.createReadStream(buildPath);
+
+      stream.on('data', (chunk) => hash.update(chunk));
+      stream.on('end', () => resolve(hash.digest('hex')));
+      stream.on('error', (err) => reject(err));
+    });
+  }
+
+  private detectMimeType(filename: string): string {
+    const fileExtension = path.extname(filename).toLowerCase();
+
+    switch (fileExtension) {
+      case '.apk':
+        return 'application/vnd.android.package-archive';
+      case '.zip':
+        return 'application/zip';
+      default:
+        return 'application/octet-stream';
+    }
+  }
+}

package/src/{channel.ts → channels/session.ts}

@@ -1,23 +1,17 @@
-import { WebSocket } from 'ws';
-import { Socket, type Channel } from 'phoenix';
+import { type Channel } from 'phoenix';
 import { SevereServiceError } from 'webdriverio';
-import { Logger } from './logger.js';
-import { getServiceInfo } from './utils.js';
+import { BaseChannel } from './base.js';
 
 import type {
   TVLabsCapabilities,
-  TVLabsSocketParams,
   TVLabsSessionRequestEventHandler,
   TVLabsSessionRequestResponse,
   LogLevel,
-} from './types.js';
-import type { PhoenixChannelJoinResponse } from './phoenix.js';
+} from '../types.js';
 
-export class TVLabsChannel {
-  private socket: Socket;
+export class SessionChannel extends BaseChannel {
   private lobbyTopic: Channel;
   private requestTopic?: Channel;
-  private log: Logger;
 
   private readonly events = {
     SESSION_READY: 'session:ready',
@@ -29,22 +23,18 @@ export class TVLabsChannel {
   } as const;
 
   constructor(
-    private endpoint: string,
-    private maxReconnectRetries: number,
-    private key: string,
-    private logLevel: LogLevel = 'info',
+    endpoint: string,
+    maxReconnectRetries: number,
+    key: string,
+    logLevel: LogLevel = 'info',
   ) {
-    this.log = new Logger('@tvlabs/wdio-channel', this.logLevel);
-    this.socket = new Socket(this.endpoint, {
-      transport: WebSocket,
-      params: this.params(),
-      reconnectAfterMs: this.reconnectAfterMs.bind(this),
-    });
-
-    this.socket.onError((...args) =>
-      TVLabsChannel.logSocketError(this.log, ...args),
+    super(
+      endpoint,
+      maxReconnectRetries,
+      key,
+      logLevel,
+      '@tvlabs/session-channel',
     );
-
     this.lobbyTopic = this.socket.channel('requests:lobby');
   }
 
@@ -58,17 +48,17 @@ export class TVLabsChannel {
 
   async connect(): Promise<void> {
     try {
-      this.log.debug('Connecting to TV Labs...');
+      this.log.debug('Connecting to session channel...');
 
       this.socket.connect();
 
       await this.join(this.lobbyTopic);
 
-      this.log.debug('Connected to TV Labs!');
+      this.log.debug('Connected to session channel!');
     } catch (error) {
-      this.log.error('Error connecting to TV Labs:', error);
+      this.log.error('Error connecting to session channel:', error);
       throw new SevereServiceError(
-        'Could not connect to TV Labs, please check your connection.',
+        'Could not connect to session channel, please check your connection.',
       );
     }
   }
@@ -193,81 +183,7 @@ export class TVLabsChannel {
     }
   }
 
-  private async join(topic: Channel): Promise<void> {
-    return new Promise((res, rej) => {
-      topic
-        .join()
-        .receive('ok', (_resp: PhoenixChannelJoinResponse) => {
-          res();
-        })
-        .receive('error', ({ response }: PhoenixChannelJoinResponse) => {
-          rej('Failed to join topic: ' + response);
-        })
-        .receive('timeout', () => {
-          rej('timeout');
-        });
-    });
-  }
-
-  private async push<T>(
-    topic: Channel,
-    event: string,
-    payload: object,
-  ): Promise<T> {
-    return new Promise((res, rej) => {
-      topic
-        .push(event, payload)
-        .receive('ok', (msg: T) => {
-          res(msg);
-        })
-        .receive('error', (reason: string) => {
-          rej(reason);
-        })
-        .receive('timeout', () => {
-          rej('timeout');
-        });
-    });
-  }
-
-  private params(): TVLabsSocketParams {
-    const serviceInfo = getServiceInfo();
-
-    this.log.debug('Info:', serviceInfo);
-
-    return {
-      ...serviceInfo,
-      api_key: this.key,
-    };
-  }
-
-  private reconnectAfterMs(tries: number) {
-    if (tries > this.maxReconnectRetries) {
-      throw new SevereServiceError(
-        'Could not connect to TV Labs, please check your connection.',
-      );
-    }
-
-    const wait = [0, 1000, 3000, 5000][tries] || 10000;
-
-    this.log.info(
-      `[${tries}/${this.maxReconnectRetries}] Waiting ${wait}ms before re-attempting to connect...`,
-    );
-
-    return wait;
-  }
-
   private tvlabsSessionLink(sessionId: string) {
     return `https://tvlabs.ai/app/sessions/${sessionId}`;
   }
-
-  private static logSocketError(
-    log: Logger,
-    event: ErrorEvent,
-    _transport: new (endpoint: string) => object,
-    _establishedConnections: number,
-  ) {
-    const error = event.error;
-
-    log.error('Socket error:', error || event);
-  }
 }

package/src/logger.ts

@@ -28,12 +28,69 @@ export class Logger {
   private formatMessage(level: LogLevel, ...args: unknown[]): string {
     const timestamp = new Date().toISOString();
     return `${timestamp} ${level.toUpperCase()} ${this.name}: ${args
-      .map((arg) =>
-        typeof arg === 'object' ? JSON.stringify(arg) : String(arg),
-      )
+      .map((arg) => this.serializeArg(arg))
       .join(' ')}`;
   }
 
+  private serializeArg(arg: unknown): string {
+    if (
+      typeof arg === 'string' ||
+      typeof arg === 'number' ||
+      typeof arg === 'boolean'
+    ) {
+      return String(arg);
+    }
+
+    if (arg === null || arg === undefined) {
+      return String(arg);
+    }
+
+    if (arg instanceof Error) {
+      // Handle Error objects specially - use stack trace which includes name and message
+      return arg.stack || `${arg.name}: ${arg.message}`;
+    }
+
+    if (typeof arg === 'object') {
+      try {
+        // Try JSON.stringify with a custom replacer to handle nested Error objects
+        const stringified = JSON.stringify(arg, (key, value) => {
+          if (value instanceof Error) {
+            return `${value.name}: ${value.message}`;
+          }
+          return value;
+        });
+
+        // If it's just an empty object, try to extract more info
+        if (stringified === '{}') {
+          // For objects that don't serialize well, try to extract key properties
+          const keys = Object.getOwnPropertyNames(arg);
+          if (keys.length > 0) {
+            const props: Record<string, unknown> = {};
+            keys.forEach((key) => {
+              try {
+                const value = (arg as Record<string, unknown>)[key];
+                if (value instanceof Error) {
+                  props[key] = `${value.name}: ${value.message}`;
+                } else {
+                  props[key] = value;
+                }
+              } catch {
+                props[key] = '[unable to access]';
+              }
+            });
+            return JSON.stringify(props);
+          }
+        }
+        return stringified;
+      } catch {
+        // Fallback to string representation if JSON.stringify fails
+        return String(arg);
+      }
+    }
+
+    return String(arg);
+  }
+
   debug(...args: unknown[]): void {
     if (this.shouldLog('debug')) {
       console.log(this.formatMessage('debug', ...args));

package/src/service.ts

@@ -1,7 +1,8 @@
 import { SevereServiceError } from 'webdriverio';
 import * as crypto from 'crypto';
 
-import { TVLabsChannel } from './channel.js';
+import { SessionChannel } from './channels/session.js';
+import { BuildChannel } from './channels/build.js';
 import { Logger } from './logger.js';
 
 import type { Services, Capabilities, Options } from '@wdio/types';
@@ -42,21 +43,41 @@ export default class TVLabsService implements Services.ServiceInstance {
     _specs: string[],
     _cid: string,
   ) {
-    const channel = new TVLabsChannel(
-      this.endpoint(),
+    const buildPath = this.buildPath();
+
+    if (buildPath) {
+      const buildChannel = new BuildChannel(
+        this.buildEndpoint(),
+        this.reconnectRetries(),
+        this.apiKey(),
+        this.logLevel(),
+      );
+
+      await buildChannel.connect();
+
+      capabilities['tvlabs:build'] = await buildChannel.uploadBuild(
+        buildPath,
+        this.appSlug(),
+      );
+
+      await buildChannel.disconnect();
+    }
+
+    const sessionChannel = new SessionChannel(
+      this.sessionEndpoint(),
       this.reconnectRetries(),
       this.apiKey(),
       this.logLevel(),
     );
 
-    await channel.connect();
+    await sessionChannel.connect();
 
-    capabilities['tvlabs:session_id'] = await channel.newSession(
+    capabilities['tvlabs:session_id'] = await sessionChannel.newSession(
       capabilities,
       this.retries(),
     );
 
-    await channel.disconnect();
+    await sessionChannel.disconnect();
   }
 
   private setupRequestId() {
@@ -101,8 +122,20 @@ export default class TVLabsService implements Services.ServiceInstance {
     }
   }
 
-  private endpoint(): string {
-    return this._options.endpoint ?? 'wss://tvlabs.ai/appium';
+  private buildPath(): string | undefined {
+    return this._options.buildPath;
+  }
+
+  private appSlug(): string | undefined {
+    return this._options.app;
+  }
+
+  private sessionEndpoint(): string {
+    return this._options.sessionEndpoint ?? 'wss://tvlabs.ai/appium';
+  }
+
+  private buildEndpoint(): string {
+    return this._options.buildEndpoint ?? 'wss://tvlabs.ai/cli';
   }
 
   private retries(): number {

package/src/types.ts

@@ -4,8 +4,11 @@ export type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'silent';
 
 export type TVLabsServiceOptions = {
   apiKey: string;
-  endpoint?: string;
+  sessionEndpoint?: string;
+  buildEndpoint?: string;
   retries?: number;
+  buildPath?: string;
+  app?: string;
   reconnectRetries?: number;
   attachRequestId?: boolean;
 };
@@ -49,3 +52,19 @@ export type TVLabsServiceInfo = {
   service_version: string;
   service_name: string;
 };
+
+export type TVLabsRequestUploadUrlResponse = {
+  url: string;
+  build_id: string;
+};
+
+export type TVLabsExtractBuildInfoResponse = {
+  application_id: string;
+};
+
+export type TVLabsBuildMetadata = {
+  filename: string;
+  type: string;
+  size: number;
+  sha256: string;
+};

package/cjs/channel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../src/channel.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,kBAAkB,EAIlB,QAAQ,EACT,MAAM,YAAY,CAAC;AAGpB,qBAAa,aAAa;IAgBtB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,GAAG;IACX,OAAO,CAAC,QAAQ;IAlBlB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,UAAU,CAAU;IAC5B,OAAO,CAAC,YAAY,CAAC,CAAU;IAC/B,OAAO,CAAC,GAAG,CAAS;IAEpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAOZ;gBAGD,QAAQ,EAAE,MAAM,EAChB,mBAAmB,EAAE,MAAM,EAC3B,GAAG,EAAE,MAAM,EACX,QAAQ,GAAE,QAAiB;IAgB/B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ3B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBxB,UAAU,CACd,YAAY,EAAE,kBAAkB,EAChC,UAAU,EAAE,MAAM,EAClB,KAAK,SAAI,GACR,OAAO,CAAC,MAAM,CAAC;YAWJ,WAAW;YAkBX,cAAc;IAsD5B,OAAO,CAAC,gBAAgB;YAUV,cAAc;YAuBd,IAAI;YAgBJ,IAAI;IAoBlB,OAAO,CAAC,MAAM;IAWd,OAAO,CAAC,gBAAgB;IAgBxB,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,MAAM,CAAC,cAAc;CAU9B"}

package/esm/channel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../src/channel.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,kBAAkB,EAIlB,QAAQ,EACT,MAAM,YAAY,CAAC;AAGpB,qBAAa,aAAa;IAgBtB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,GAAG;IACX,OAAO,CAAC,QAAQ;IAlBlB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,UAAU,CAAU;IAC5B,OAAO,CAAC,YAAY,CAAC,CAAU;IAC/B,OAAO,CAAC,GAAG,CAAS;IAEpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAOZ;gBAGD,QAAQ,EAAE,MAAM,EAChB,mBAAmB,EAAE,MAAM,EAC3B,GAAG,EAAE,MAAM,EACX,QAAQ,GAAE,QAAiB;IAgB/B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ3B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBxB,UAAU,CACd,YAAY,EAAE,kBAAkB,EAChC,UAAU,EAAE,MAAM,EAClB,KAAK,SAAI,GACR,OAAO,CAAC,MAAM,CAAC;YAWJ,WAAW;YAkBX,cAAc;IAsD5B,OAAO,CAAC,gBAAgB;YAUV,cAAc;YAuBd,IAAI;YAgBJ,IAAI;IAoBlB,OAAO,CAAC,MAAM;IAWd,OAAO,CAAC,gBAAgB;IAgBxB,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,MAAM,CAAC,cAAc;CAU9B"}