Job Hunter

License: MIT (see LICENSE.)

A .NET MAUI desktop application for searching, bookmarking, and applying to jobs. Persistence uses the OS application data folder (%AppData% on Windows, equivalent on macOS/Linux). You can search and bookmark without a profile; a profile is required for one-click apply. Jobs are scored against your must-haves and nice-to-haves and sorted by score.

Features

• Search – Search jobs from multiple providers (Dummy implementation included; ZipRecruiter, Indeed, LinkedIn stubbed).
• Bookmark – Save jobs for later; open URL, remove, or apply (with profile).
• Apply – With a profile, apply from search or bookmarks; applications are tracked with communications.
• Profile – Optional but encouraged: resume path, contact info, must-haves and nice-to-haves for scoring and apply.
• Scoring – Each job is scored against your criteria; results are sorted by score descending.
• Communications – Record outbound/inbound notes per application; applications sorted by most activity; flag offers with optional salary.

Requirements

• .NET 8 SDK (or .NET 9; the project builds with either)
• The MAUI app uses Microsoft.NET.Sdk with Microsoft.Maui.Controls 8.0.100 so the workload provides Run and Mac Catalyst support. The MAUI workload must be installed for the app to build and run:
  • macOS: dotnet workload install maui (you may be prompted for your password)
  • Windows: dotnet workload install maui (run PowerShell as Administrator if needed)

Without the workload you can still build and test the core library: use JobHunter.Core.Tests.sln (see Building below).

---

Quick Start (Mac)

1. Clone and go to the repo

   cd /path/to/job_hunter

2. Install the MAUI workload (one-time; you may be prompted for your password)

   dotnet workload install maui

3. Build the app

   dotnet build JobHunter/JobHunter.csproj -f net8.0-maccatalyst

4. Run the app (builds the .app bundle and launches it)

   ./scripts/run-mac.sh

   Or: dotnet build JobHunter/JobHunter.csproj -t:Run -f net8.0-maccatalyst

5. (Optional) Run tests: dotnet test JobHunter.Tests/JobHunter.Tests.csproj
   (Optional) Open job site in browser for Playwright: ./scripts/open-browser.sh

---

Quick Start (PC / Windows)

1. Clone and go to the repo

   cd C:\path\to\job_hunter

2. Install the MAUI workload (one-time; run PowerShell as Administrator if needed)

   dotnet workload install maui

3. Build the app

   dotnet build JobHunter\JobHunter.csproj -f net8.0-windows10.0.19041.0

4. Run the app

   .\scripts\run-windows.ps1

   Or: dotnet run --project JobHunter\JobHunter.csproj -f net8.0-windows10.0.19041.0

5. (Optional) Run tests: dotnet test JobHunter.Tests\JobHunter.Tests.csproj
   (Optional) Open job site in browser for Playwright: .\scripts\open-browser.ps1

---

Building

Option A – Build without MAUI workload (Core + Tests only)
Always works; use this if you haven’t installed the MAUI workload:

dotnet build JobHunter.Core.Tests.sln

Or use the build script (tries full solution first, then falls back to Core + Tests):

./scripts/build.sh          # macOS/Linux
# or
./scripts/build.ps1         # Windows PowerShell

Option B – Build full solution (including MAUI app)
Requires the MAUI workload (one-time, may need elevated privileges):

dotnet workload install maui
# On macOS/Linux you may need: sudo dotnet workload install maui

Then either use the script or build directly:

./scripts/install-workload-and-build.sh   # macOS/Linux (installs workload then builds)
# or
dotnet build JobHunter.sln

Build only the MAUI app or a specific platform:

# On macOS, specify the framework to avoid Windows targeting errors:
dotnet build JobHunter/JobHunter.csproj -f net8.0-maccatalyst
# On Windows:
dotnet build JobHunter/JobHunter.csproj -f net8.0-windows10.0.19041.0

Running

From the repository root:

Windows:

dotnet run --project JobHunter/JobHunter.csproj -f net8.0-windows10.0.19041.0

macOS:

dotnet run --project JobHunter/JobHunter.csproj -f net8.0-maccatalyst

Or after building: run the app from your IDE or the executable in JobHunter/bin/Debug/<tfm>/ (e.g. JobHunter.app on macOS, .exe on Windows).

Open browser for Playwright recording

After launching the app, you can open your default browser to a job site (e.g. for Playwright codegen recording):

./scripts/open-browser.sh    # macOS/Linux (default: ZipRecruiter jobs)
# or
./scripts/open-browser.ps1   # Windows PowerShell

To use a different URL, set JOB_HUNTER_BROWSER_URL (e.g. https://www.indeed.com) before running the script, or edit the script.

Running tests

From the repository root:

dotnet test JobHunter.Tests/JobHunter.Tests.csproj

To run tests for the whole solution:

dotnet test

To run with verbose output:

dotnet test JobHunter.Tests/JobHunter.Tests.csproj --logger "console;verbosity=detailed"

Troubleshooting

"The target Run does not exist" / "ComputeRunArguments does not exist"
The project uses Microsoft.NET.Sdk with the MAUI workload; Run is provided by the workload. Install: dotnet workload install maui.

"JobHunter.app does not exist" when running on Mac
The Run target tries to open the Mac Catalyst .app bundle; if the bundle was not created during build, run fails. Repair the workload (requires elevated privileges), then build and run again:

sudo dotnet workload repair
# or
sudo dotnet workload config --update-mode manifests

Then run again with ./scripts/run-mac.sh or dotnet build -t:Run -f net8.0-maccatalyst.

Data location

All data is stored under the application data folder:

• Windows: %AppData%\JobHunter
• macOS: ~/Library/Application Support/JobHunter
• Linux: ~/.config/JobHunter (or equivalent from Environment.SpecialFolder.ApplicationData)

---

Using Playwright to record a session and export C# code

You can use Playwright’s Codegen to record browser actions (e.g. on job sites) and get C# code that you can later plug into automation or tests.

1. Install Playwright for .NET

In a test or console project that will host the generated code:

dotnet add package Microsoft.Playwright

Then install browser binaries (one-time):

pwsh bin/Debug/net8.0/playwright.ps1 install
# or, from project directory:
dotnet build
pwsh ./bin/Debug/net8.0/playwright.ps1 install

2. Run Codegen

From the project directory (where playwright.ps1 was generated), run:

pwsh bin/Debug/net8.0/playwright.ps1 codegen

Or open a specific URL:

pwsh bin/Debug/net8.0/playwright.ps1 codegen https://www.example.com/jobs

Two windows open:

• Browser – You perform the actions (search, click, type, navigate).
• Playwright Inspector – Shows the generated C# code as you interact.

3. Record the session

In the browser:

• Enter search terms, click search, open a job, fill forms, etc.
• Each action is translated into C# in the Inspector (e.g. await page.ClickAsync(...), await page.FillAsync(...)).

Optional: save auth state so you can reuse it later:

pwsh bin/Debug/net8.0/playwright.ps1 codegen --save-storage=auth.json https://job-site.com

After logging in and recording, the session state is stored in auth.json for use in tests or scripts.

4. Export as C#

• In the Playwright Inspector, the C# code is shown in the right panel.
• Copy the generated code (or use the copy button if available).
• Paste it into a C# file in your solution, for example:
  • JobHunter.Tests/Recorded_ZipRecruiter_SearchAndApply.cs, or
  • A dedicated automation project.

Example of what you might get:

await page.GotoAsync("https://www.ziprecruiter.com/jobs");
await page.GetByRole(AriaRole.Textbox, new() { Name = "Keyword" }).FillAsync("software engineer");
await page.GetByRole(AriaRole.Button, new() { Name = "Search" }).ClickAsync();
// ... more steps

Wrap this in a test or helper method and run it with Playwright’s IPage/IBrowserContext from your test setup.

5. Optional: tracing for debugging

To capture a trace (screenshots, snapshots, network) while running your recorded or custom script:

await context.Tracing.StartAsync(new TracingStartOptions
{
    Screenshots = true,
    Snapshots = true,
    Sources = true
});

// ... your recorded or manual steps ...

await context.Tracing.StopAsync(new TracingStopOptions { Path = "trace.zip" });

Open the trace:

• Run: pwsh bin/Debug/net8.0/playwright.ps1 show-trace trace.zip
• Or upload trace.zip to trace.playwright.dev

This helps debug failures and inspect what happened during the run.

---

Project structure

• JobHunter – MAUI app (Shell, Search, Bookmarks, Applications, Profile, DI).
• JobHunter.Core – Models, IJobProvider, Dummy + ZipRecruiter/Indeed/LinkedIn stubs, ScoringService, CommunicationManager, persistence (AppData).
• JobHunter.Tests – XUnit tests: stubbed provider tests, Dummy, Scoring, and persistence tests.