jobcrawl 0.1.0

package/.prettierrc.json

@@ -0,0 +1,10 @@
+{
+  "semi": true,
+  "trailingComma": "es5",
+  "singleQuote": false,
+  "printWidth": 80,
+  "tabWidth": 2,
+  "useTabs": false,
+  "arrowParens": "always",
+  "endOfLine": "lf"
+}

package/CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.0] - 2026-04-02
+
+Initial release of jobcrawl — a CLI tool that discovers and crawls company career pages to find matching job listings.
+
+### Added
+
+- **Project scaffold** — TypeScript project with Prettier, ESM modules, and core dependencies.
+- **Type system** — Shared type definitions (`Company`, `Job`, `CrawlResult`, `AggregatorResult`) and a typed event bus for inter-module communication.
+- **ATS provider extractors** — Built-in support for Greenhouse, Lever, and Ashby career pages with structured job extraction.
+- **Generic provider** — Fallback extractor using LLM-powered container-based extraction strategy for non-standard career pages.
+- **Provider detection** — Automatic ATS provider identification from page HTML and URL patterns.
+- **iframe resolution** — Detects and resolves iframe-embedded career pages to their source URLs.
+- **Career page discovery** — Finds career pages via Google search and heuristic URL guessing (e.g. `/careers`, `/jobs`).
+- **Job matching** — LLM-based relevance scoring to filter jobs against user-defined search criteria.
+- **Crawl orchestration** — Bounded concurrency pool for parallel crawling with progress tracking.
+- **YC aggregator** — Scrapes Y Combinator's Work at a Startup with extended search filters (role, location, industry) and raw data capture.
+- **Aggregator architecture** — Separated aggregator type from direct providers, with dedicated CLI commands and crawl orchestration.
+- **Browser rendering** — Integrated `agent-browser` for JavaScript-rendered pages that can't be crawled with static HTTP fetches.
+- **Companies dataset** — Built-in dataset of ~2,800 companies for `init` config generation.
+- **CLI with Ink UI** — Interactive terminal interface with step-based thread progress, plus plain-text output mode.
+- **CLI commands** — `init`, `crawl`, `crawl-url`, `crawl-aggregators`, and `discover` commands.
+- **Config system** — YAML-based configuration for companies, search criteria, and crawl settings.
+- **Output formatting** — Structured JSON and human-readable output for crawl results.
+- **Raw data capture** — Optional saving of raw HTML/JSON responses for debugging.
+- **Test suite** — Unit tests (detect-provider, match-jobs, resolve-iframe, config, events, format-output, pool, generic provider) and integration tests (process-url, Ashby, Greenhouse, Lever providers).
+
+### Fixed
+
+- Job deduplication now uses URL+title composite key instead of URL alone, preventing false duplicates across pages.
+- File permissions restricted on credentials and config directory during `init`.
+
+### Changed
+
+- Removed `dotenv` dependency — environment variables are expected to be set externally.
+- Rewrote CrawlView component with step-based thread progress for clearer status reporting.
+- Rewrote README to cover aggregators, browser rendering, and the new config format.

package/README.md

@@ -0,0 +1,232 @@
+# jobcrawl
+
+CLI tool that crawls career pages for jobs matching your search criteria. Supports Greenhouse, Ashby, and Lever via their public JSON APIs, Y Combinator's Work at a Startup via Algolia, and custom career pages via browser rendering + DOM heuristics.
+
+## Install
+
+```bash
+npm install
+npm run build
+```
+
+Requires Node.js 20+. Optional dependencies:
+
+- `ANTHROPIC_API_KEY` — for the `discover` command's LLM features
+- `agent-browser` — for JS-rendered career pages (`npm i -g agent-browser`)
+
+## Quick start
+
+```bash
+# Create config at ~/.jobcrawl/config.yaml + credentials.json
+jobcrawl init
+
+# Add your YC Algolia credentials to ~/.jobcrawl/credentials.json
+# Then crawl
+jobcrawl crawl --keywords "engineer" --output table
+
+# Or search YC startups directly
+jobcrawl crawl-aggregators yc --keywords "engineer" --role engineering
+```
+
+## Commands
+
+### `init` — Create config files
+
+Creates `~/.jobcrawl/config.yaml` (pre-populated with 200+ companies), `~/.jobcrawl/credentials.json` (for aggregator API keys), and `~/.jobcrawl/raw/` directory.
+
+```bash
+jobcrawl init           # Create default config
+jobcrawl init --force   # Overwrite existing config
+```
+
+### `crawl` — Crawl career pages
+
+```bash
+# Uses ~/.jobcrawl/config.yaml by default
+jobcrawl crawl --keywords "engineer" --output table
+
+# From a specific config file
+jobcrawl crawl --file config.yaml --keywords "engineer"
+
+# From inline URLs
+jobcrawl crawl --urls https://boards.greenhouse.io/anthropic https://jobs.ashbyhq.com/openai \
+  --keywords "senior" "engineer" --remote
+
+# Include YC aggregator alongside company targets
+jobcrawl crawl --aggregators yc --keywords "engineer" --company-stage seed
+
+# Pipe to jq
+jobcrawl crawl --keywords "staff" | jq '.[].title'
+```
+
+### `crawl-url` — Crawl a single URL
+
+```bash
+jobcrawl crawl-url https://boards.greenhouse.io/anthropic --keywords "engineer" --output table
+```
+
+### `crawl-aggregators` — Search aggregator sources
+
+Searches across multiple companies in one query. Currently supports YC (Work at a Startup).
+
+```bash
+# Search YC startups
+jobcrawl crawl-aggregators yc --keywords "engineer" --output table
+
+# With extended filters
+jobcrawl crawl-aggregators yc --keywords "engineer" --role engineering --role-type backend \
+  --company-stage seed --has-salary --visa-sponsorship
+```
+
+Requires Algolia credentials in `~/.jobcrawl/credentials.json` or via env vars `YC_ALGOLIA_APP_ID` and `YC_ALGOLIA_API_KEY`.
+
+### `discover` — Find career pages from company names
+
+```bash
+# Output URLs (one per line)
+jobcrawl discover --companies "Anthropic" "OpenAI" "Mistral AI"
+
+# Save as YAML config
+jobcrawl discover --companies "Anthropic" "OpenAI" --output yaml -o ~/.jobcrawl/config.yaml
+
+# Pipe discover into crawl
+jobcrawl discover --companies "Anthropic" | jobcrawl crawl --keywords "engineer"
+```
+
+### `detect` — Identify ATS provider
+
+```bash
+jobcrawl detect https://boards.greenhouse.io/anthropic
+# → { "provider": "greenhouse", "boardToken": "anthropic" }
+```
+
+### `match` — Filter a saved jobs file
+
+```bash
+jobcrawl crawl-url https://jobs.ashbyhq.com/openai -o jobs.json
+jobcrawl match jobs.json --keywords "senior" --remote --output table
+```
+
+## Search criteria flags
+
+| Flag | Description |
+|------|-------------|
+| `--keywords <terms...>` | Job title keywords (any match) |
+| `--exclude <terms...>` | Exclude jobs matching these keywords |
+| `--location <location>` | Location substring filter |
+| `--remote` | Only remote jobs |
+| `--onsite` | Only onsite jobs |
+| `--hybrid` | Only hybrid jobs |
+| `--department <depts...>` | Department filter |
+| `--role <roles...>` | Role category: engineering, design, product, science, sales, marketing, etc. |
+| `--role-type <types...>` | Specialization: backend, frontend, full-stack, ML, DevOps, etc. |
+| `--job-type <types...>` | fulltime, internship, contract |
+| `--company-stage <stages...>` | seed, series-a, growth, scale |
+| `--industry <industries...>` | Industry filter |
+| `--company-size <sizes...>` | 1-10, 11-50, 51-300, 301+ |
+| `--has-salary` | Only jobs with salary listed |
+| `--has-equity` | Only jobs with equity |
+| `--has-interview-process` | Only jobs with interview process listed |
+| `--visa-sponsorship` | Jobs offering visa sponsorship |
+
+## Output formats
+
+`--output json` (default), `table`, `markdown`, `csv`
+
+Write to file with `-o <file>`. Save raw API responses with `--save-raw` (stored in `~/.jobcrawl/raw/`).
+
+## Config file
+
+Located at `~/.jobcrawl/config.yaml`. Created by `jobcrawl init`.
+
+```yaml
+# Aggregators (cross-company search engines)
+aggregators:
+  - type: yc
+    enabled: true
+
+# Companies — slug-based (recommended) or URL-based
+companies:
+  # --- AI Foundation Models ---
+  - company: Anthropic
+    slug: anthropic
+    provider: greenhouse
+  - company: OpenAI
+    slug: openai
+    provider: ashby
+
+  # URL-based (also works)
+  - url: https://mistral.ai/careers/
+    company: Mistral AI
+
+defaults:
+  concurrency: 5
+```
+
+**Slug-based targets** (recommended): jobcrawl auto-probes Greenhouse, Ashby, and Lever APIs using the slug. Add an optional `provider` hint to skip probing, or a `fallback` URL for when no ATS API matches.
+
+**URL-based targets**: directly probe the URL, falling back to browser rendering for JS-rendered pages.
+
+Target resolution order:
+1. `--urls` flag (inline URLs)
+2. `--file` flag (explicit config file)
+3. `~/.jobcrawl/config.yaml` (default config)
+4. `stdin` (piped input)
+
+## Credentials
+
+`~/.jobcrawl/credentials.json` stores API keys for aggregators:
+
+```json
+{
+  "yc": {
+    "algoliaAppId": "YOUR_APP_ID",
+    "algoliaApiKey": "YOUR_API_KEY"
+  }
+}
+```
+
+Alternatively, set `YC_ALGOLIA_APP_ID` and `YC_ALGOLIA_API_KEY` environment variables.
+
+## How it works
+
+**Three-tier extraction:**
+
+1. **Tier 1 (API-first)** — Quick HTTP probe detects ATS signals (Greenhouse, Ashby, Lever iframes/embeds), then calls their public JSON APIs directly. No browser needed. Sub-second.
+
+2. **Tier 2 (Browser rendering)** — For custom career pages, renders with agent-browser (Chrome via CDP), then extracts jobs via DOM heuristics: link-based extraction for pages with job links, or container-based extraction for pages with structured job cards.
+
+3. **Tier 3 (Aggregator)** — Searches cross-company job engines like YC's Work at a Startup (Algolia API). Runs in parallel with target crawling; results are deduplicated.
+
+**Architecture:**
+
+```
+~/.jobcrawl/
+├── config.yaml            # Targets + aggregators + defaults
+├── credentials.json       # API keys for aggregators
+└── raw/                   # Saved raw API responses
+
+src/
+├── events.ts              # Typed EventBus (pub/sub)
+├── types/                 # Shared type definitions
+├── data/                  # Curated companies dataset
+├── core/                  # Pure primitives (fetch, detect, extract, match)
+│   ├── providers/         # Greenhouse, Ashby, Lever, generic extractors
+│   ├── aggregators/       # YC (Algolia)
+│   └── browser.ts         # agent-browser wrapper (render, click-capture)
+├── threads/               # Per-URL pipeline + bounded concurrency pool
+├── orchestrators/         # Multi-URL + aggregator coordination
+├── utils/                 # Config loading, LLM, web search
+└── entrypoints/cli/       # Commander.js + Ink terminal UI
+    └── components/        # CrawlView, DiscoverView (React/Ink)
+```
+
+## Supported providers
+
+| Provider | Detection | Extraction |
+|----------|-----------|------------|
+| Greenhouse | URL, iframe, `#grnhse_app`, embed script | Public JSON API |
+| Ashby | URL, iframe, embed markers | Public JSON API |
+| Lever | URL, iframe, `data-lever-*` | Public JSON API |
+| YC (Work at a Startup) | Aggregator config | Algolia search API |
+| Custom | Fallback | Browser render + DOM heuristics |

package/dist/core/aggregators/yc.d.ts

@@ -0,0 +1,7 @@
+import type { Job, SearchCriteria } from "../../types/index.js";
+/**
+ * Fetch jobs from YC's Work at a Startup via Algolia.
+ * Maps SearchCriteria to Algolia filters. Falls back to URL query params
+ * for backward compatibility with direct WaaS URLs.
+ */
+export declare function extractYcJobs(sourceUrl: string, criteria: SearchCriteria, saveRaw?: boolean): Promise<Job[]>;

package/dist/core/aggregators/yc.js

@@ -0,0 +1,320 @@
+import { createHash } from "node:crypto";
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { saveRawResponse } from "../save-raw.js";
+const HITS_PER_PAGE = 100;
+const INDEX_BY_DATE = "WaaSPublicCompanyJob_created_at_desc_production";
+const INDEX_BY_RELEVANCE = "WaaSPublicCompanyJob_production";
+// --- Value mapping tables ---
+const ROLE_MAP = {
+    engineering: "eng",
+    design: "design",
+    product: "product",
+    science: "science",
+    sales: "sales",
+    marketing: "marketing",
+    support: "support",
+    operations: "operations",
+    "recruiting-hr": "recruiting",
+    finance: "finance",
+    legal: "legal",
+};
+const ENG_TYPE_MAP = {
+    android: "android",
+    backend: "be",
+    "data-science": "data_sci",
+    devops: "devops",
+    "embedded-systems": "embedded",
+    "engineering-manager": "eng_mgmt",
+    frontend: "fe",
+    "full-stack": "fs",
+    ios: "ios",
+    "machine-learning": "ml",
+    "qa-engineer": "qa",
+    robotics: "robotics",
+    hardware: "hw",
+    electrical: "electrical",
+    mechanical: "mechanical",
+    bioengineering: "bio",
+    "chemical-engineering": "chemical",
+};
+const DESIGN_TYPE_MAP = {
+    "web-design": "web",
+    "mobile-design": "mobile",
+    "product-design": "product",
+    "ui-ux": "ui_ux",
+    "user-research": "user_research",
+    "brand-graphic-design": "brand_graphic",
+    illustration: "illustration",
+    animation: "animation",
+    hardware: "hardware",
+    "3d-ar-vr": "ar_vr",
+    "design-manager": "design_mgmt",
+};
+const SCIENCE_TYPE_MAP = {
+    biology: "bio",
+    biotechnology: "biotech",
+    chemistry: "chem",
+    genetics: "genetics",
+    healthcare: "health",
+    immunology: "immuno",
+    laboratory: "lab",
+    oncology: "onc",
+    pharmacology: "pharma",
+    "process-engineer": "process",
+    research: "research",
+};
+const JOB_TYPE_MAP = {
+    fulltime: "fulltime",
+    internship: "intern",
+    contract: "contract",
+};
+const COMPANY_STAGE_MAP = {
+    seed: "seed",
+    "series-a": "series_a",
+    growth: "growth",
+    scale: "scale",
+};
+const WORK_MODE_MAP = {
+    remote: "only",
+    onsite: "no",
+    hybrid: "yes",
+};
+const ROLE_TYPE_FIELD_MAP = {
+    eng: "eng_type",
+    design: "design_type",
+    science: "science_type",
+};
+const ROLE_TYPE_VALUE_MAP = {
+    eng: ENG_TYPE_MAP,
+    design: DESIGN_TYPE_MAP,
+    science: SCIENCE_TYPE_MAP,
+};
+const COMPANY_SIZE_MAP = {
+    "1-10": "company_team_size <= 10",
+    "11-50": "company_team_size: 11 TO 50",
+    "51-300": "company_team_size: 51 TO 300",
+    "301+": "company_team_size >= 301",
+};
+// --- Filter helpers ---
+function mapValues(values, map) {
+    return values.map((v) => map[v] ?? v);
+}
+function orFilter(field, values, quoted = false) {
+    const parts = values.map((v) => quoted ? `${field}:"${v}"` : `${field}:${v}`);
+    return `(${parts.join(" OR ")})`;
+}
+function buildFilters(criteria, sourceUrl) {
+    const params = new URL(sourceUrl).searchParams;
+    const filters = [];
+    // role
+    const roles = criteria.role
+        ? mapValues(criteria.role, ROLE_MAP)
+        : fallbackArray(params, "role");
+    if (roles.length > 0)
+        filters.push(orFilter("role", roles));
+    // roleType → field depends on role
+    if (criteria.roleType && criteria.role) {
+        const algoliaRoles = mapValues(criteria.role, ROLE_MAP);
+        for (const algoliaRole of algoliaRoles) {
+            const field = ROLE_TYPE_FIELD_MAP[algoliaRole];
+            const valueMap = ROLE_TYPE_VALUE_MAP[algoliaRole];
+            if (field && valueMap) {
+                const mapped = mapValues(criteria.roleType, valueMap);
+                filters.push(orFilter(field, mapped));
+            }
+        }
+    }
+    else {
+        const roleTypeParam = params.get("role_type");
+        if (roleTypeParam && roleTypeParam !== "any")
+            filters.push(`(eng_type:${roleTypeParam})`);
+    }
+    // workMode → remote
+    const remoteModes = criteria.workMode
+        ? mapValues(criteria.workMode, WORK_MODE_MAP)
+        : fallbackArray(params, "remote");
+    if (remoteModes.length > 0)
+        filters.push(orFilter("remote", remoteModes));
+    // location
+    const location = criteria.location ?? params.get("locations");
+    if (location && location !== "any")
+        filters.push(`(locations_for_search:"${location}")`);
+    // jobType
+    const jobTypes = criteria.jobType
+        ? mapValues(criteria.jobType, JOB_TYPE_MAP)
+        : fallbackArray(params, "jobType");
+    if (jobTypes.length > 0)
+        filters.push(orFilter("job_type", jobTypes, true));
+    // minExperience
+    const minExps = criteria.minExperience
+        ? criteria.minExperience.map(String)
+        : fallbackArray(params, "minExperience");
+    if (minExps.length > 0)
+        filters.push(orFilter("min_experience", minExps));
+    // companyStage
+    const stages = criteria.companyStage
+        ? mapValues(criteria.companyStage, COMPANY_STAGE_MAP)
+        : fallbackArray(params, "companyStage");
+    if (stages.length > 0)
+        filters.push(orFilter("company_waas_stage", stages));
+    // industry
+    const industries = criteria.industry ?? fallbackQuotedArray(params, "industry");
+    if (industries.length > 0)
+        filters.push(orFilter("company_parent_sector", industries, true));
+    // companySize → range syntax
+    if (criteria.companySize && criteria.companySize.length > 0) {
+        const rangeClauses = criteria.companySize
+            .map((s) => COMPANY_SIZE_MAP[s])
+            .filter(Boolean);
+        if (rangeClauses.length > 0)
+            filters.push(`(${rangeClauses.join(" OR ")})`);
+    }
+    // hasSalary
+    if (criteria.hasSalary)
+        filters.push("(has_salary:true)");
+    // hasEquity
+    if (criteria.hasEquity)
+        filters.push("(has_equity:true)");
+    // hasInterviewProcess
+    if (criteria.hasInterviewProcess)
+        filters.push("(has_interview_process:true)");
+    // visaSponsorship
+    if (criteria.visaSponsorship)
+        filters.push("(us_visa_required:none OR us_visa_required:possible)");
+    return filters.join(" AND ");
+}
+function fallbackArray(params, key) {
+    const val = params.get(key);
+    if (!val || val === "any")
+        return [];
+    return [val];
+}
+function fallbackQuotedArray(params, key) {
+    const val = params.get(key);
+    if (!val || val === "any")
+        return [];
+    return [val];
+}
+// --- Algolia API ---
+async function fetchPage(appId, apiKey, query, filters, indexName, page) {
+    const algoliaParams = new URLSearchParams({
+        query,
+        page: String(page),
+        filters,
+        attributesToRetrieve: JSON.stringify(["*"]),
+        attributesToHighlight: JSON.stringify([]),
+        attributesToSnippet: JSON.stringify([]),
+        hitsPerPage: String(HITS_PER_PAGE),
+        clickAnalytics: "true",
+        distinct: "true",
+    });
+    const url = `https://${appId}-dsn.algolia.net/1/indexes/*/queries?x-algolia-agent=${encodeURIComponent("Algolia for JavaScript (3.35.1); Browser")}&x-algolia-application-id=${appId}&x-algolia-api-key=${apiKey}`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            accept: "application/json",
+            "content-type": "application/x-www-form-urlencoded",
+            Origin: "https://www.workatastartup.com",
+            Referer: "https://www.workatastartup.com/",
+        },
+        body: JSON.stringify({
+            requests: [
+                {
+                    indexName,
+                    params: algoliaParams.toString(),
+                },
+            ],
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Algolia API returned ${response.status}`);
+    }
+    return (await response.json());
+}
+// --- Job mapping ---
+function mapHit(hit, sourceUrl) {
+    const id = createHash("sha256")
+        .update(`${hit.objectID}:${hit.title}:yc`)
+        .digest("hex")
+        .slice(0, 12);
+    const jobUrl = hit.search_path ??
+        `https://www.workatastartup.com/jobs/${hit.objectID}`;
+    return {
+        id,
+        title: hit.title,
+        company: hit.company_name,
+        location: hit.locations_for_search?.[0] ?? null,
+        workMode: inferWorkMode(hit.remote),
+        department: hit.role ?? null,
+        url: jobUrl,
+        sourceUrl,
+        provider: "yc",
+        description: hit.description?.slice(0, 200) ?? null,
+        postedAt: hit.created_at ?? null,
+        extractedAt: new Date().toISOString(),
+        raw: hit,
+    };
+}
+function inferWorkMode(remote) {
+    if (!remote)
+        return null;
+    const r = remote.toLowerCase();
+    if (r === "only" || r === "yes")
+        return "remote";
+    if (r === "no")
+        return null;
+    return null;
+}
+// --- Entry point ---
+/**
+ * Fetch jobs from YC's Work at a Startup via Algolia.
+ * Maps SearchCriteria to Algolia filters. Falls back to URL query params
+ * for backward compatibility with direct WaaS URLs.
+ */
+export async function extractYcJobs(sourceUrl, criteria, saveRaw = false) {
+    let appId = process.env.YC_ALGOLIA_APP_ID;
+    let apiKey = process.env.YC_ALGOLIA_API_KEY;
+    if (!appId || !apiKey) {
+        const credPath = join(homedir(), ".jobcrawl", "credentials.json");
+        if (existsSync(credPath)) {
+            const creds = JSON.parse(readFileSync(credPath, "utf-8"));
+            appId = appId || creds.yc?.algoliaAppId;
+            apiKey = apiKey || creds.yc?.algoliaApiKey;
+        }
+    }
+    if (!appId || !apiKey) {
+        throw new Error("YC provider requires credentials. Run `jobcrawl init` and add your Algolia keys to ~/.jobcrawl/credentials.json");
+    }
+    const queries = criteria.keywords.length > 0
+        ? criteria.keywords
+        : [""];
+    const filters = buildFilters(criteria, sourceUrl);
+    // Fetch each keyword as a separate Algolia query and deduplicate
+    const jobMap = new Map();
+    const allHits = [];
+    for (const query of queries) {
+        const indexName = query ? INDEX_BY_RELEVANCE : INDEX_BY_DATE;
+        const first = await fetchPage(appId, apiKey, query, filters, indexName, 0);
+        const result = first.results[0];
+        for (const hit of result.hits) {
+            if (!jobMap.has(hit.objectID)) {
+                jobMap.set(hit.objectID, mapHit(hit, sourceUrl));
+                allHits.push(hit);
+            }
+        }
+        for (let page = 1; page < result.nbPages; page++) {
+            const resp = await fetchPage(appId, apiKey, query, filters, indexName, page);
+            for (const hit of resp.results[0].hits) {
+                if (!jobMap.has(hit.objectID)) {
+                    jobMap.set(hit.objectID, mapHit(hit, sourceUrl));
+                    allHits.push(hit);
+                }
+            }
+        }
+    }
+    if (saveRaw)
+        await saveRawResponse("yc", "workatastartup", allHits);
+    return [...jobMap.values()];
+}

package/dist/core/browser.d.ts

@@ -0,0 +1,30 @@
+import type { Job } from "../types/index.js";
+export declare class BrowserNotAvailableError extends Error {
+    constructor();
+}
+export declare class BrowserSession {
+    private name;
+    private opened;
+    private networkTimeout;
+    constructor(opts?: {
+        networkTimeout?: number;
+    });
+    /** Run a local DOM command (no timeout). */
+    private run;
+    /** Run a network-dependent command (open, wait) with a timeout. */
+    private runNetwork;
+    open(url: string): Promise<void>;
+    getHtml(): Promise<string>;
+    getUrl(): Promise<string>;
+    clickByText(text: string): Promise<void>;
+    /**
+     * Find an element by its exact text content, walk up `level` ancestors,
+     * and click that parent. Uses eval with base64 to avoid shell quoting.
+     */
+    clickNthParent(text: string, level: number): Promise<void>;
+    back(): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function resolveJobUrls(jobs: Job[], listingUrl: string, session: BrowserSession, opts?: {
+    maxBubbleLevels?: number;
+}): Promise<Job[]>;