@epsilon-asi/actors 0.0.3 → 0.0.4

package/src/sites/myvistage-com/myvistage-com.actor.ts

@@ -0,0 +1,50 @@
+import { defineLoginFlow } from '../../auth/LoginFlow.types.js';
+import { defineFormFillerTask } from '../../core/Actor.js';
+import { defineActor } from '../../core/defineActor.js';
+import { myvistageComSelectors } from './myvistage-com.selectors.js';
+import type {
+  PingInput,
+  PingOutput,
+  PostCommentInput,
+  PostCommentOutput
+} from './myvistage-com.types.js';
+
+export const myvistageComActor = defineActor({
+  id: 'myvistage-com',
+  baseUrl: 'https://myvistage.com',
+  auth: defineLoginFlow({
+    loginUrl: 'https://myvistage.com',
+    selectors: myvistageComSelectors.login,
+    credentials: { id: 'myvistage-com' },
+    behavior: {
+      authCheckUrl: '/',
+      submitCausesNavigation: true,
+      loggedInTimeoutMs: 5_000,
+      errorTimeoutMs: 1_500,
+      typing: {
+        targetWordsPerMinute: 65,
+        intervalJitterMs: 18
+      }
+    }
+  }),
+  tasks: {
+    ping: async (_context, input: PingInput = {}): Promise<PingOutput> => ({
+      ok: true,
+      echo: input.message ?? null
+    }),
+    postComment: defineFormFillerTask<PostCommentInput, PostCommentOutput>({
+      url: '/?status/151341-151341-1779377493/',
+      fields: [
+        { selector: myvistageComSelectors.postComment.comment, inputKey: 'comment' },
+        { selector: myvistageComSelectors.postComment.subject, inputKey: 'subject', required: false }
+      ],
+      submit: {
+        selector: myvistageComSelectors.postComment.submit
+      },
+      onComplete: (_context, input) => ({
+        submittedComment: input.comment,
+        submittedSubject: input.subject ?? null
+      })
+    })
+  }
+});

package/src/sites/myvistage-com/myvistage-com.selectors.ts

@@ -0,0 +1,14 @@
+export const myvistageComSelectors = {
+  login: {
+    username: '[name="username"]',
+    password: '[name="password"]',
+    submit: '#form-login button[type="submit"]',
+    loggedInSignal: 'a[href*="logout"], a[href*="signout"]',
+    errorMessage: '#mv3login [role="alert"], #mv3login .error, #mv3login .woocommerce-error'
+  },
+  postComment: {
+    comment: 'textarea[name="comment"]',
+    subject: 'input[name="subject"]',
+    submit: 'div:nth-of-type(2) > div:nth-of-type(2) > div:nth-of-type(1) > button:nth-of-type(2)'
+  }
+} as const;

package/src/sites/myvistage-com/myvistage-com.types.ts

@@ -0,0 +1,18 @@
+export interface PingInput {
+  message?: string;
+}
+
+export interface PingOutput {
+  ok: true;
+  echo: string | null;
+}
+
+export interface PostCommentInput extends Record<string, string | undefined> {
+  comment: string;
+  subject?: string;
+}
+
+export interface PostCommentOutput {
+  submittedComment: string;
+  submittedSubject: string | null;
+}

package/src/sites/myvistage-com/post-comment-action.json

@@ -0,0 +1,81 @@
+[
+  {
+    "actionType": "click",
+    "frameUrl": "https://myvistage.com/?status/151341-151341-1779377493/",
+    "id": "evt_1779456308524_qrd1e362",
+    "input": null,
+    "metadata": {
+      "ariaLabel": null,
+      "button": 0,
+      "buttons": 0,
+      "clientX": 529,
+      "clientY": 1042,
+      "id": null,
+      "inputType": null,
+      "label": "Write a comment...",
+      "name": "comment",
+      "pageX": 529,
+      "pageY": 1042,
+      "role": null,
+      "sensitive": false,
+      "tagName": "textarea"
+    },
+    "selector": "[placeholder=\"Write a comment...\"]",
+    "sessionId": "session_1779456305296_opr4xo87",
+    "tagName": "textarea",
+    "text": null,
+    "timestamp": "2026-05-22T13:25:08.522Z",
+    "url": "https://myvistage.com/?status/151341-151341-1779377493/"
+  },
+  {
+    "actionType": "input",
+    "frameUrl": "https://myvistage.com/?status/151341-151341-1779377493/",
+    "id": "evt_1779456314495_qrzdnyxn",
+    "input": null,
+    "metadata": {
+      "ariaLabel": null,
+      "id": null,
+      "inputType": null,
+      "label": "Write a comment...",
+      "name": "comment",
+      "role": null,
+      "sensitive": false,
+      "tagName": "textarea",
+      "valueLength": null
+    },
+    "selector": "[placeholder=\"Write a comment...\"]",
+    "sessionId": "session_1779456305296_opr4xo87",
+    "tagName": "textarea",
+    "text": null,
+    "timestamp": "2026-05-22T13:25:14.139Z",
+    "url": "https://myvistage.com/?status/151341-151341-1779377493/"
+  },
+  {
+    "actionType": "click",
+    "frameUrl": "https://myvistage.com/?status/151341-151341-1779377493/",
+    "id": "evt_1779456319321_fujuvmqc",
+    "input": null,
+    "metadata": {
+      "ariaLabel": null,
+      "button": 0,
+      "buttons": 0,
+      "clientX": 1167,
+      "clientY": 1042,
+      "id": null,
+      "inputType": null,
+      "label": "Post",
+      "name": null,
+      "pageX": 1167,
+      "pageY": 1042,
+      "role": null,
+      "sensitive": false,
+      "tagName": "button"
+    },
+    "selector": "div:nth-of-type(2) > div:nth-of-type(2) > div:nth-of-type(1) > button:nth-of-type(2)",
+    "sessionId": "session_1779456305296_opr4xo87",
+    "tagName": "button",
+    "text": "Post",
+    "timestamp": "2026-05-22T13:25:19.320Z",
+    "url": "https://myvistage.com/?status/151341-151341-1779377493/"
+  }
+]

package/src/sites/upwork-com/index.ts

@@ -0,0 +1,6 @@
+export * from './upwork-com.actor.js';
+export * from './upwork-com.selectors.js';
+export * from './upwork-com.types.js';
+export {parseRate} from "./upwork-com.util.js";
+
+export {buildSearchParams} from "./upwork-com.util.js";

package/src/sites/upwork-com/upwork-com.actor.ts

@@ -0,0 +1,97 @@
+import {defineLoginFlow} from '../../auth/LoginFlow.types.js';
+import {defineActor} from '../../core/defineActor.js';
+import {upworkComSelectors} from './upwork-com.selectors.js';
+import type {
+  UpworkApplyToJobInput,
+  UpworkApplyToJobResult,
+  UpworkJobSearchFields,
+  UpworkJobSearchResult
+} from './upwork-com.types.js';
+import {buildSearchParams, parseRate} from "./upwork-com.util.js";
+
+export const upworkComActor = defineActor({
+  id: 'upwork-com',
+  baseUrl: 'https://upwork.com',
+  auth: defineLoginFlow({
+    loginUrl: 'https://www.upwork.com/ab/account-security/login',
+    selectors: {
+      loggedInSignal: upworkComSelectors.login.loggedInSignal,
+      errorMessage: upworkComSelectors.login.errorMessage
+    },
+    credentials: { id: 'upwork' },
+    behavior: {
+      authCheckUrl: '/',
+      loggedInTimeoutMs: 5_000,
+      errorTimeoutMs: 1_500,
+      typing: {
+        targetWordsPerMinute: 65,
+        intervalJitterMs: 18
+      }
+    },
+    steps: [
+      {
+        type: 'fill',
+        name: 'username',
+        selector: upworkComSelectors.login.username,
+        credential: 'username'
+      },
+      {
+        type: 'click',
+        name: 'continue to password',
+        selector: upworkComSelectors.login.continueToPassword,
+        waitForSelector: upworkComSelectors.login.password,
+        waitForSelectorTimeoutMs: 5_000
+      },
+      {
+        type: 'fill',
+        name: 'password',
+        selector: upworkComSelectors.login.password,
+        credential: 'password'
+      },
+      {
+        type: 'click',
+        name: 'submit password',
+        selector: upworkComSelectors.login.submit,
+        submit: true,
+        waitForNavigation: true,
+        checkForError: false
+      }
+    ]
+  }),
+  tasks: {
+    searchJobs: async (context, input: UpworkJobSearchFields = {}): Promise<any> => {
+      const path = '/nx/s/universal-search/jobs?client_hires=1-9,10-&payment_verified=1&q=%27rancher%27%20or%20%27terraform%27%20or%20%27gitops%27%20or%20%27azure%27%20or%20%27microsoft%20azure%27%20or%20%27cloud%20architect%27%20or%20%27ai%20architect%27%20or%20%27forward%20deployed%20engineer%27%20or%20%27aws%27%20or%20%27aks%27%20or%20%27eks%27%20or%20%27gke%27%20or%20%27cloud%20engineer%27%20or%20devops%20or%20kuberentes%20or%20%27platform%20engineer%27%20or%20%27infrastructure%20engineer%27%20or%20"google%20cloud%20platform"%20or%20"GCP"%20or%20"langsmith"%20or%20"langgraph"%20or%20"gemini%20enterprise"&sort=recency&user_location_match=1';
+
+      await context.nav.goto(path, {});
+
+      console.log(context.page.raw());
+
+      // Get by classname class="jobs-main-panel - get all children of article type
+      // loop through each. Check
+        //
+      //
+    },
+    applyToJob: async (_context, input: UpworkApplyToJobInput): Promise<UpworkApplyToJobResult> => {
+      const coverLetter = input.coverLetter.trim();
+      if (coverLetter.length === 0) {
+        throw new Error('coverLetter must be a non-empty string.');
+      }
+
+      const rate = parseRate(input.rate);
+      if (!Number.isFinite(rate) || rate <= 0) {
+        throw new Error('rate must be a positive number.');
+      }
+
+      return {
+        coverLetter,
+        rate
+      };
+    }
+  }
+});
+
+
+const likeScript = `reactions.action_reactions(this, 1632181); `
+const commentScript = `activity.comment_save(1630927, this);`
+
+

package/src/sites/upwork-com/upwork-com.runner.ts

@@ -0,0 +1,17 @@
+import {ActorRunner} from "../../core/index.js";
+import {upworkComActor} from "./upwork-com.actor.js";
+
+const runner = new ActorRunner({
+    config: {
+        browser: {
+            mode: 'remote-debugging',
+        }
+    }
+});
+
+
+const run = async () => {
+    await runner.run(upworkComActor, 'searchJobs', {} as any)
+}
+
+run().catch(e=>console.error(e)).then(r=>console.log(r))

package/src/sites/upwork-com/upwork-com.selectors.ts

@@ -0,0 +1,10 @@
+export const upworkComSelectors = {
+  login: {
+    username: '#login_username',
+    password: '#login_password',
+    continueToPassword: '#login_password_continue',
+    submit: '#login_control_continue',
+    loggedInSignal: '[data-test="nav-user-dropdown"]',
+    errorMessage: '#login_error'
+  }
+} as const;

package/src/sites/upwork-com/upwork-com.types.ts

@@ -0,0 +1,102 @@
+export enum JobSearchSort {
+  BestMatch = 'best_match',
+}
+
+export enum DomesticFilter {
+  USOnly = 'us_only',
+}
+
+export enum ContractorTier {
+  EntryLevel = '1',
+  Intermediate = '2',
+  Expert = '3',
+}
+
+export enum JobType {
+  Hourly = 'hourly',
+  FixedPrice = 'fixed_price',
+}
+
+export enum FixedPriceRange {
+  LessThan100 = 'lt_100',
+  From100To500 = '100_to_500',
+  From500To1000 = '500_to_1000',
+  From1000To5000 = '1000_to_5000',
+  GreaterThan5000 = 'gte_5000',
+}
+
+export enum ProposalRange {
+  FewerThan5 = '0-4',
+  From5To10 = '5-9',
+  From10To15 = '10-14',
+  From15To20 = '15-19',
+  From20To50 = '20-49',
+}
+
+export enum ClientInfoFilter {
+  PreviousClients = 'previous_clients',
+  PaymentVerified = 'payment_verified',
+}
+
+export enum ClientHiresRange {
+  NoHires = '0',
+  From1To9 = '1-9',
+  TenPlus = '10-',
+}
+
+export enum ProjectLength {
+  LessThanOneMonth = 'week',
+  OneToThreeMonths = 'month',
+  ThreeToSixMonths = 'semester',
+  MoreThanSixMonths = 'ongoing',
+}
+
+export enum HoursPerWeek {
+  LessThan30 = 'as_needed',
+  MoreThan30 = 'full_time',
+}
+
+export enum JobDuration {
+  ContractToHire = 'contract_to_hire',
+}
+
+export type MoneyRange = {
+  min?: number;
+  max?: number;
+  currency?: 'USD';
+};
+
+export type UpworkJobSearchFields = {
+  sort?: JobSearchSort;
+  domestic?: DomesticFilter;
+  categories?: string[];
+  contractorTier?: ContractorTier[];
+  jobType?: JobType[];
+  hourlyRate?: MoneyRange;
+  fixedPriceRanges?: FixedPriceRange[];
+  fixedPriceCustom?: MoneyRange;
+  proposals?: ProposalRange[];
+  clientInfo?: ClientInfoFilter[];
+  clientHires?: ClientHiresRange[];
+  clientLocations?: string[];
+  clientTimezones?: string[];
+  projectLength?: ProjectLength[];
+  hoursPerWeek?: HoursPerWeek[];
+  jobDuration?: JobDuration[];
+};
+
+export interface UpworkJobSearchResult {
+  searchUrl: string;
+  query: string;
+  filters: UpworkJobSearchFields;
+}
+
+export interface UpworkApplyToJobInput {
+  coverLetter: string;
+  rate: number | string;
+}
+
+export interface UpworkApplyToJobResult {
+  coverLetter: string;
+  rate: number;
+}

package/src/sites/upwork-com/upwork-com.util.ts

@@ -0,0 +1,41 @@
+import type {UpworkApplyToJobInput, UpworkJobSearchFields} from "./upwork-com.types.js";
+
+export function buildSearchParams(input: UpworkJobSearchFields): URLSearchParams {
+    const params = new URLSearchParams();
+
+    if (input.sort !== undefined) params.set('sort', input.sort);
+    if (input.domestic !== undefined) params.set('domestic', input.domestic);
+    appendList(params, 'categories', input.categories);
+    appendList(params, 'contractor_tier', input.contractorTier);
+    appendList(params, 'job_type', input.jobType);
+
+    if (input.hourlyRate?.min !== undefined) params.set('hourly_rate_min', String(input.hourlyRate.min));
+    if (input.hourlyRate?.max !== undefined) params.set('hourly_rate_max', String(input.hourlyRate.max));
+    if (input.hourlyRate?.currency !== undefined) params.set('hourly_rate_currency', input.hourlyRate.currency);
+
+    appendList(params, 'fixed_price_ranges', input.fixedPriceRanges);
+    if (input.fixedPriceCustom?.min !== undefined) params.set('fixed_price_min', String(input.fixedPriceCustom.min));
+    if (input.fixedPriceCustom?.max !== undefined) params.set('fixed_price_max', String(input.fixedPriceCustom.max));
+    if (input.fixedPriceCustom?.currency !== undefined) params.set('fixed_price_currency', input.fixedPriceCustom.currency);
+
+    appendList(params, 'proposals', input.proposals);
+    appendList(params, 'client_info', input.clientInfo);
+    appendList(params, 'client_hires', input.clientHires);
+    appendList(params, 'client_locations', input.clientLocations);
+    appendList(params, 'client_timezones', input.clientTimezones);
+    appendList(params, 'project_length', input.projectLength);
+    appendList(params, 'hours_per_week', input.hoursPerWeek);
+    appendList(params, 'job_duration', input.jobDuration);
+
+    return params;
+}
+
+function appendList(params: URLSearchParams, key: string, values: readonly string[] | undefined): void {
+    if (values === undefined || values.length === 0) return;
+    params.set(key, values.join(','));
+}
+
+export function parseRate(rate: UpworkApplyToJobInput['rate']): number {
+    if (typeof rate === 'number') return rate;
+    return Number(rate.trim());
+}

package/src/utils/delay.ts

@@ -0,0 +1,4 @@
+export function delay(ms: number): Promise<void> {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+export * from './delay.js';
+export * from './invariant.js';
+export * from './redact.js';
+export * from './retry.js';
+export * from './url.js';

package/src/utils/invariant.ts

@@ -0,0 +1,7 @@
+import { ConfigError } from '../errors/ConfigError.js';
+
+export function invariant(condition: unknown, message: string): asserts condition {
+  if (!condition) {
+    throw new ConfigError(message);
+  }
+}

package/src/utils/redact.ts

@@ -0,0 +1,53 @@
+const DEFAULT_REDACTION_KEYS = [
+  'password',
+  'passwd',
+  'secret',
+  'token',
+  'apiKey',
+  'api_key',
+  'authorization',
+  'auth',
+  'cookie',
+  'session',
+  'credential',
+  'refreshToken',
+  'accessToken'
+];
+
+export interface RedactOptions {
+  replacement?: string;
+  sensitiveKeys?: string[];
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function keyIsSensitive(key: string, sensitiveKeys: string[]): boolean {
+  const normalized = key.toLowerCase();
+  return sensitiveKeys.some(sensitiveKey => normalized.includes(sensitiveKey.toLowerCase()));
+}
+
+export function redact<T>(value: T, options: RedactOptions = {}): T {
+  const replacement = options.replacement ?? '[REDACTED]';
+  const sensitiveKeys = options.sensitiveKeys ?? DEFAULT_REDACTION_KEYS;
+
+  const visit = (input: unknown): unknown => {
+    if (Array.isArray(input)) {
+      return input.map(item => visit(item));
+    }
+
+    if (!isPlainObject(input)) {
+      return input;
+    }
+
+    return Object.fromEntries(
+      Object.entries(input).map(([key, nestedValue]) => [
+        key,
+        keyIsSensitive(key, sensitiveKeys) ? replacement : visit(nestedValue)
+      ])
+    );
+  };
+
+  return visit(value) as T;
+}

package/src/utils/retry.ts

@@ -0,0 +1,31 @@
+import { delay } from './delay.js';
+
+export interface RetryPolicy {
+  attempts: number;
+  baseDelayMs: number;
+  maxDelayMs?: number;
+  jitter?: boolean;
+}
+
+export async function retry<T>(fn: () => Promise<T>, policy: RetryPolicy): Promise<T> {
+  if (!Number.isInteger(policy.attempts) || policy.attempts < 1) {
+    throw new Error('Retry attempts must be a positive integer.');
+  }
+
+  let lastError: unknown;
+  for (let attempt = 1; attempt <= policy.attempts; attempt += 1) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === policy.attempts) break;
+
+      const exponentialDelay = policy.baseDelayMs * 2 ** (attempt - 1);
+      const cappedDelay = Math.min(exponentialDelay, policy.maxDelayMs ?? exponentialDelay);
+      const jitter = policy.jitter ? Math.floor(Math.random() * Math.max(1, cappedDelay / 3)) : 0;
+      await delay(cappedDelay + jitter);
+    }
+  }
+
+  throw lastError;
+}

package/src/utils/url.ts

@@ -0,0 +1,7 @@
+export function resolveUrl(baseUrl: string, urlOrPath: string): string {
+  try {
+    return new URL(urlOrPath).toString();
+  } catch {
+    return new URL(urlOrPath, baseUrl).toString();
+  }
+}

package/tests/fixtures/FakeCredentialsProvider.ts

@@ -0,0 +1,12 @@
+import type { CredentialRef, Credentials, CredentialsProvider } from '../../src/auth/CredentialsProvider.js';
+
+export class FakeCredentialsProvider implements CredentialsProvider {
+  readonly requested: CredentialRef[] = [];
+
+  constructor(private readonly credentials: Credentials = { username: 'user@example.com', password: 'secret' }) {}
+
+  async getCredentials(ref: CredentialRef): Promise<Credentials> {
+    this.requested.push(ref);
+    return this.credentials;
+  }
+}

package/tests/fixtures/FakeCursor.ts

@@ -0,0 +1,48 @@
+import type { HumanClickOptions, HumanInteractor, HumanMoveOptions, HumanTypeOptions } from '../../src/interaction/HumanInteractor.js';
+
+export class FakeHumanInteractor implements HumanInteractor {
+  clicks: Array<{ selector: string; options?: HumanClickOptions }> = [];
+  moves: Array<{ selector: string; options?: HumanMoveOptions }> = [];
+  typed: Array<{ selector: string; value: string; options?: HumanTypeOptions }> = [];
+  scrolled: string[] = [];
+
+  async click(selector: string, options?: HumanClickOptions): Promise<void> {
+    const record: { selector: string; options?: HumanClickOptions } = { selector };
+    if (options !== undefined) record.options = options;
+    this.clicks.push(record);
+  }
+
+  async move(selector: string, options?: HumanMoveOptions): Promise<void> {
+    const record: { selector: string; options?: HumanMoveOptions } = { selector };
+    if (options !== undefined) record.options = options;
+    this.moves.push(record);
+  }
+
+  async type(selector: string, value: string, options?: HumanTypeOptions): Promise<void> {
+    const record: { selector: string; value: string; options?: HumanTypeOptions } = { selector, value };
+    if (options !== undefined) record.options = options;
+    this.typed.push(record);
+  }
+
+  async scrollIntoView(selector: string): Promise<void> {
+    this.scrolled.push(selector);
+  }
+}
+
+export class FakeGhostCursor {
+  clicks: Array<{ selector?: string; options?: Record<string, unknown> }> = [];
+  moves: Array<{ selector: string; options?: Record<string, unknown> }> = [];
+
+  async click(selector?: string, options?: Record<string, unknown>): Promise<void> {
+    const record: { selector?: string; options?: Record<string, unknown> } = {};
+    if (selector !== undefined) record.selector = selector;
+    if (options !== undefined) record.options = options;
+    this.clicks.push(record);
+  }
+
+  async move(selector: string, options?: Record<string, unknown>): Promise<void> {
+    const record: { selector: string; options?: Record<string, unknown> } = { selector };
+    if (options !== undefined) record.options = options;
+    this.moves.push(record);
+  }
+}