gethired 0.1.0__tar.gz

gethired-0.1.0/.gitignore

@@ -0,0 +1,21 @@
+.venv/
+.uv-cache/
+__pycache__/
+*.pyc
+.pytest_cache/
+backend/out/
+backend/.claude/
+*.db
+.DS_Store
+node_modules/
+.npm-cache/
+backend/app/static/
+backend/dist/
+backend/data/
+frontend/tsconfig.tsbuildinfo
+handoff.md
+resume/
+.claude/worktrees/
+frontend/.playwright/
+frontend/test-results/
+frontend/playwright-report/

gethired-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.5
+Name: gethired
+Version: 0.1.0
+Summary: 내 이력서에 맞는 채용 공고만 모아 보여주는 로컬 앱
+Project-URL: Homepage, https://github.com/chaewonkong/job-posting
+Requires-Python: >=3.14
+Requires-Dist: claude-agent-sdk>=0.2.165
+Requires-Dist: fastapi>=0.115
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: platformdirs>=4.3
+Requires-Dist: pydantic>=2.14.0
+Requires-Dist: pypdf>=6.21.1
+Requires-Dist: uvicorn[standard]>=0.30

gethired-0.1.0/app/__main__.py

@@ -0,0 +1,87 @@
+"""`gethired [serve|auth|reset-db|paths]` — 빌드된 프론트(app/static)를 정적 서빙하며 API 실행.
+`python -m app [--port N] [--demo]`도 같다 (서브커맨드 생략 = serve)."""
+import argparse
+import asyncio
+import sys
+import threading
+import webbrowser
+
+import uvicorn
+
+from . import auth, config
+
+COMMANDS = ("serve", "auth", "reset-db", "paths")
+LOGIN_COMMAND = {"claude": "claude login", "codex": f"{config.CODEX_BIN} login"}
+
+
+def _load_app():
+    from .main import app
+    return app
+
+
+def _serve(args: argparse.Namespace) -> None:
+    if not config.FRONTEND_DIST.exists():
+        print(f"warning: {config.FRONTEND_DIST} not found — frontend not built (API only)", file=sys.stderr)
+    if args.demo:
+        from .demo import make_app
+        app = make_app()
+    else:
+        app = _load_app()
+    url = f"http://{args.host}:{args.port}"
+    if not args.no_open:
+        threading.Timer(1.0, webbrowser.open, [url]).start()
+    print(f"gethired: {url}", file=sys.stderr)
+    uvicorn.run(app, host=args.host, port=args.port)
+
+
+def _auth(args: argparse.Namespace) -> None:
+    ok = asyncio.run(auth.is_logged_in(args.provider))
+    print(f"{args.provider}: {'logged in' if ok else 'not logged in — run `' + LOGIN_COMMAND[args.provider] + '`'}")
+    sys.exit(0 if ok else 1)
+
+
+def _reset_db(args: argparse.Namespace) -> None:
+    if config.DB_PATH.exists():
+        config.DB_PATH.unlink()
+        print(f"removed {config.DB_PATH}")
+    else:
+        print(f"no db at {config.DB_PATH}")
+
+
+def _paths(args: argparse.Namespace) -> None:
+    print(f"home:     {config.HOME}")
+    print(f"db:       {config.DB_PATH}")
+    print(f"resume:   {config.RESUME_DIR}")
+    print(f"frontend: {config.FRONTEND_DIST}")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    ap = argparse.ArgumentParser(prog="gethired")
+    sub = ap.add_subparsers(dest="command", required=True)
+
+    serve = sub.add_parser("serve", help="서버 실행 후 브라우저 열기 (기본)")
+    serve.add_argument("--host", default="127.0.0.1")
+    serve.add_argument("--port", type=int, default=8000)
+    serve.add_argument("--no-open", action="store_true", help="브라우저를 열지 않음")
+    serve.add_argument("--demo", action="store_true", help="고정 데이터 데모 모드 (네트워크·LLM·실제 경로 없음)")
+    serve.set_defaults(func=_serve)
+
+    au = sub.add_parser("auth", help="provider CLI 로그인 상태 확인")
+    au.add_argument("provider", nargs="?", default="claude", choices=("claude", "codex"))
+    au.set_defaults(func=_auth)
+
+    sub.add_parser("reset-db", help="공고·판정 이력 삭제").set_defaults(func=_reset_db)
+    sub.add_parser("paths", help="데이터 경로 출력").set_defaults(func=_paths)
+    return ap
+
+
+def main(argv: list[str] | None = None) -> None:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if not argv or argv[0] not in COMMANDS and argv[0] not in ("-h", "--help"):
+        argv.insert(0, "serve")
+    args = build_parser().parse_args(argv)
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

gethired-0.1.0/app/api.py

@@ -0,0 +1,170 @@
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+from typing import Literal
+
+from fastapi import APIRouter, FastAPI, HTTPException, Query, Request
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+from . import auth, resume
+from .config import RESUME_DIR
+from .jobs import JobManager
+from .llm import LOGIN_COMMAND, PROVIDERS, auth_message, resolve_provider
+from .repository import Repository, now_iso
+
+
+class InterestsBody(BaseModel):
+    companies: list[str]
+
+
+class ProviderBody(BaseModel):
+    provider: str
+
+
+def create_app(repo: Repository, jobs: JobManager,
+               logged_in: Callable[[str], Awaitable[bool]] = auth.is_logged_in,
+               resume_dir: Path = RESUME_DIR) -> FastAPI:
+    app = FastAPI(title="gethired")
+    api = APIRouter(prefix="/api")
+
+    def provider_setting() -> dict:
+        stored = repo.get_setting("provider")
+        return {"provider": resolve_provider(stored), "chosen": stored is not None}
+
+    async def auth_status_body() -> dict:
+        provider = provider_setting()["provider"]
+        return {"provider": provider, "logged_in": await logged_in(provider), "login_command": LOGIN_COMMAND[provider]}
+
+    def job_running() -> bool:
+        return bool(jobs.current and jobs.current.status == "running")
+
+    @api.get("/settings/provider")
+    def get_provider():
+        return provider_setting()
+
+    @api.put("/settings/provider")
+    async def put_provider(body: ProviderBody):
+        if body.provider not in PROVIDERS:
+            raise HTTPException(status_code=400, detail=f"unknown provider: {body.provider}")
+        if job_running():
+            return JSONResponse(status_code=409, content={"code": "job_running",
+                                                          "message": "스크래핑 중에는 AI를 바꿀 수 없습니다."})
+        repo.set_setting("provider", body.provider, now_iso())
+        return await auth_status_body()
+
+    @api.get("/auth/status")
+    async def auth_status():
+        return await auth_status_body()
+
+    @api.get("/companies")
+    def companies():
+        last = repo.last_runs()
+        interests = set(repo.list_interests())
+        return [
+            {"company": name, "display_name": cls.display_name, "careers_url": cls.careers_url,
+             "last_run": last.get(name), "interested": name in interests}
+            for name, cls in jobs.scrapers.items()
+        ]
+
+    def check_known(companies: list[str]) -> None:
+        unknown = [c for c in companies if c not in jobs.scrapers]
+        if unknown:
+            raise HTTPException(status_code=400, detail=f"unknown companies: {unknown}")
+
+    @api.put("/interests")
+    def put_interests(body: InterestsBody):
+        if not body.companies:
+            raise HTTPException(status_code=400, detail="at least one company is required")
+        check_known(body.companies)
+        repo.set_interests(body.companies, now_iso())
+        return {"companies": repo.list_interests()}
+
+    def interest(company: str, on: bool):
+        check_known([company])
+        repo.set_interest(company, on, now_iso())
+        return {"company": company, "interested": on}
+
+    @api.put("/companies/{company}/interest")
+    def add_interest(company: str):
+        return interest(company, True)
+
+    @api.delete("/companies/{company}/interest")
+    def remove_interest(company: str):
+        return interest(company, False)
+
+    @api.post("/scrape", status_code=202)
+    async def scrape(companies: list[str] | None = Query(default=None)):
+        if job_running():
+            return {"job_id": jobs.current.id, "status": "running"}
+        provider = provider_setting()["provider"]
+        if not await logged_in(provider):
+            return JSONResponse(status_code=401, content={"code": "login_required", "provider": provider,
+                                                          "message": auth_message(provider)})
+        check_known(companies or [])
+        targets = companies or [c for c in repo.list_interests() if c in jobs.scrapers]
+        if not targets:
+            raise HTTPException(status_code=400, detail="no interest companies")
+        job = jobs.start(targets)
+        return {"job_id": job.id, "status": job.status}
+
+    @api.get("/scrape/{job_id}")
+    def scrape_status(job_id: str):
+        job = jobs.get(job_id)
+        if not job:
+            raise HTTPException(status_code=404, detail="job not found")
+        return job.to_dict()
+
+    @api.get("/postings")
+    def postings(company: str | None = None, min_level: Literal["stretch", "good", "strong"] | None = None):
+        return repo.list_postings(company=company, min_level=min_level)
+
+    def bookmark(posting_id: int, on: bool):
+        if not repo.set_bookmark(posting_id, on, now_iso()):
+            raise HTTPException(status_code=404, detail="posting not found")
+        return {"posting_id": posting_id, "bookmarked": on}
+
+    @api.put("/postings/{posting_id}/bookmark")
+    def add_bookmark(posting_id: int):
+        return bookmark(posting_id, True)
+
+    @api.delete("/postings/{posting_id}/bookmark")
+    def remove_bookmark(posting_id: int):
+        return bookmark(posting_id, False)
+
+    def hide(posting_id: int, on: bool):
+        if not repo.set_hidden(posting_id, on, now_iso()):
+            raise HTTPException(status_code=404, detail="posting not found")
+        return {"posting_id": posting_id, "hidden": on}
+
+    @api.put("/postings/{posting_id}/hide")
+    def add_hide(posting_id: int):
+        return hide(posting_id, True)
+
+    @api.delete("/postings/{posting_id}/hide")
+    def remove_hide(posting_id: int):
+        return hide(posting_id, False)
+
+    @api.get("/resume")
+    def resume_files():
+        return resume.list_files(resume_dir)
+
+    @api.put("/resume/{name}")
+    async def put_resume(name: str, request: Request):
+        try:
+            await resume.save(resume_dir, name, request.stream())
+        except ValueError as e:
+            raise HTTPException(status_code=400, detail=str(e))
+        return {}
+
+    @api.delete("/resume/{name}")
+    def delete_resume(name: str):
+        try:
+            found = resume.delete(resume_dir, name)
+        except ValueError as e:
+            raise HTTPException(status_code=400, detail=str(e))
+        if not found:
+            raise HTTPException(status_code=404, detail="resume file not found")
+        return {"name": name}
+
+    app.include_router(api)
+    return app

gethired-0.1.0/app/auth.py

@@ -0,0 +1,61 @@
+import asyncio
+import json
+
+from . import config
+
+STATUS_TIMEOUT_S = 15
+
+_inflight: dict[str, asyncio.Future] = {}
+
+
+async def is_logged_in(provider: str) -> bool:
+    """provider CLI의 로그인 상태. CLI가 없거나 실패·타임아웃이면 False. 같은 provider의 동시 호출은 결과를 공유한다."""
+    fut = _inflight.get(provider)
+    if fut is None or fut.done():
+        fut = asyncio.ensure_future(_check(provider))
+        _inflight[provider] = fut
+        fut.add_done_callback(lambda _: _inflight.pop(provider, None))
+    return await asyncio.shield(fut)
+
+
+async def _check(provider: str) -> bool:
+    return await (_codex_status() if provider == "codex" else _claude_status())
+
+
+async def _claude_status() -> bool:
+    """`claude auth status`의 loggedIn"""
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "claude", "auth", "status", stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.DEVNULL)
+    except OSError:
+        return False
+    try:
+        out, _ = await asyncio.wait_for(proc.communicate(), timeout=STATUS_TIMEOUT_S)
+        return bool(json.loads(out.decode() or "{}").get("loggedIn"))
+    except asyncio.TimeoutError:
+        _kill(proc)
+        return False
+    except json.JSONDecodeError:
+        return False
+
+
+async def _codex_status() -> bool:
+    """`codex login status`의 exit code 0"""
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            config.CODEX_BIN, "login", "status",
+            stdout=asyncio.subprocess.DEVNULL, stderr=asyncio.subprocess.DEVNULL)
+    except OSError:
+        return False
+    try:
+        return await asyncio.wait_for(proc.wait(), timeout=STATUS_TIMEOUT_S) == 0
+    except asyncio.TimeoutError:
+        _kill(proc)
+        return False
+
+
+def _kill(proc: asyncio.subprocess.Process) -> None:
+    try:
+        proc.kill()
+    except ProcessLookupError:
+        pass

gethired-0.1.0/app/config.py

@@ -0,0 +1,21 @@
+import os
+from pathlib import Path
+
+from platformdirs import user_data_dir
+
+APP_DIR = Path(__file__).resolve().parent
+FRONTEND_DIST = APP_DIR / "static"
+
+# 사용자 데이터. 개발 시에는 justfile이 DB_PATH·RESUME_DIR로 저장소 안 경로를 넘긴다
+HOME = Path(os.environ.get("GETHIRED_HOME") or user_data_dir("gethired"))
+DB_PATH = Path(os.environ.get("DB_PATH") or HOME / "app.db")
+RESUME_DIR = Path(os.environ.get("RESUME_DIR") or HOME / "resume")
+
+MATCH_BATCH_SIZE = 20
+MATCH_CONCURRENCY = 4
+
+LLM_PROVIDER = os.environ.get("LLM_PROVIDER", "claude")
+LLM_TIMEOUT_S = float(os.environ.get("LLM_TIMEOUT_S", "600"))
+CLAUDE_MODEL = os.environ.get("CLAUDE_MODEL", "claude-opus-5-5")
+CODEX_BIN = os.environ.get("CODEX_BIN", "codex")
+CODEX_MODEL = os.environ.get("CODEX_MODEL") or None

gethired-0.1.0/app/demo.py

@@ -0,0 +1,201 @@
+"""데모 모드: 스크래퍼·프로필·판정을 고정 데이터로 바꾼 백엔드. 네트워크·LLM·CLI·실제 경로를 쓰지 않는다.
+모든 텍스트는 가상이다."""
+import asyncio
+import os
+import sys
+import tempfile
+from datetime import date
+from pathlib import Path
+from typing import Any, ClassVar
+
+import httpx
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+
+from .api import create_app
+from .config import FRONTEND_DIST
+from .jobs import JobManager
+from .matcher import Match
+from .profile import Preferences, Profile
+from .repository import Repository, set_fixed_now
+from .scrapers import RawPosting, Scraper
+
+FIXED_NOW = "2026-10-18T09:00:00+09:00"
+DEMO_JUDGE_DELAY_S = 0.7
+
+COMPANIES = ("toss", "daangn", "kakao", "naver")
+
+
+def _url(company: str, n: int) -> str:
+    return f"https://example.com/demo/{company}/{n}"
+
+
+POSTINGS: dict[str, list[RawPosting]] = {
+    "toss": [
+        RawPosting(company="toss", external_id="demo-toss-1", title="서버 개발자 (Go)", apply_url=_url("toss", 1),
+                   category="Engineering",
+                   description="Go로 대규모 트래픽을 처리하는 코어 서버를 개발합니다. Redis·Kubernetes 기반 운영 경험과 "
+                               "분산 시스템 설계 경험을 우대합니다. 5년 이상의 백엔드 경력을 기대합니다."),
+        RawPosting(company="toss", external_id="demo-toss-2", title="결제 플랫폼 백엔드", apply_url=_url("toss", 2),
+                   category="Engineering",
+                   description="결제 승인·정산 파이프라인을 설계하고 운영합니다. Kotlin 또는 Go, PostgreSQL, "
+                               "메시지 큐 경험을 요구하며 금융 도메인 경험은 우대입니다."),
+    ],
+    "daangn": [
+        RawPosting(company="daangn", external_id="demo-daangn-1", title="매칭 플랫폼 백엔드 엔지니어",
+                   apply_url=_url("daangn", 1), category="Software Engineer", deadline=date(2026, 10, 22),
+                   description="이웃 간 거래·모임을 연결하는 매칭 플랫폼의 백엔드를 만듭니다. Go, Redis, Kubernetes 환경에서 "
+                               "지연과 공정성을 함께 다루는 매칭 로직을 설계·운영한 경험을 찾습니다."),
+        RawPosting(company="daangn", external_id="demo-daangn-2", title="데이터 플랫폼 엔지니어",
+                   apply_url=_url("daangn", 2), category="Software Engineer",
+                   description="이벤트 수집 파이프라인과 분석용 저장소를 운영합니다. Spark·Airflow·ClickHouse 등 "
+                               "데이터 인프라 경험과 Python 기반 배치 개발 경험을 요구합니다."),
+    ],
+    "kakao": [
+        RawPosting(company="kakao", external_id="demo-kakao-1", title="게임 서버 백엔드 (Kotlin)",
+                   apply_url=_url("kakao", 1), category="서버",
+                   description="모바일 게임의 매치메이킹·랭킹·보상 서버를 개발합니다. Kotlin/Spring 필수, "
+                               "실시간 트래픽 처리와 Redis 기반 세션 관리 경험을 우대합니다."),
+        RawPosting(company="kakao", external_id="demo-kakao-2", title="인프라 엔지니어", apply_url=_url("kakao", 2),
+                   category="인프라",
+                   description="사내 Kubernetes 플랫폼과 관측 스택을 운영합니다. Terraform·Ansible 기반 프로비저닝, "
+                               "네트워크·스토리지 운영 경험을 요구합니다."),
+    ],
+    "naver": [
+        RawPosting(company="naver", external_id="demo-naver-1", title="검색 플랫폼 백엔드 (Java)",
+                   apply_url=_url("naver", 1), category="Tech",
+                   description="검색 색인·질의 서빙 플랫폼을 개발합니다. Java/Spring 필수, 대용량 분산 저장소 운영 경험과 "
+                               "검색 품질 개선 경험을 우대합니다."),
+        RawPosting(company="naver", external_id="demo-naver-2", title="실시간 메시징 서버", apply_url=_url("naver", 2),
+                   category="Tech",
+                   description="수천만 사용자가 쓰는 실시간 메시징 서버를 개발합니다. Go 또는 Java, 분산 시스템과 "
+                               "WebSocket·pub/sub 설계 경험을 요구합니다."),
+    ],
+}
+
+
+class DemoScraper(Scraper, register=False):
+    expected_count: ClassVar[int] = 2
+
+    async def fetch(self, client: httpx.AsyncClient) -> list[RawPosting]:
+        return list(POSTINGS[self.company])
+
+
+class DemoToss(DemoScraper, register=False):
+    company = "toss"
+    display_name = "토스"
+    careers_url = "https://toss.im/career/jobs"
+
+
+class DemoDaangn(DemoScraper, register=False):
+    company = "daangn"
+    display_name = "당근"
+    careers_url = "https://about.daangn.com/jobs/"
+
+
+class DemoKakao(DemoScraper, register=False):
+    company = "kakao"
+    display_name = "카카오"
+    careers_url = "https://careers.kakao.com/jobs"
+
+
+class DemoNaver(DemoScraper, register=False):
+    company = "naver"
+    display_name = "네이버"
+    careers_url = "https://recruit.navercorp.com/rcrt/list.do"
+
+
+SCRAPERS: dict[str, type[Scraper]] = {"toss": DemoToss, "daangn": DemoDaangn, "kakao": DemoKakao, "naver": DemoNaver}
+
+PROFILE = Profile(
+    name="홍길동", seniority="senior", years_experience=5,
+    core_skills=["Go", "Redis", "Kubernetes", "PostgreSQL"],
+    familiar_skills=["TypeScript", "gRPC", "ClickHouse"],
+    weak_or_learning=["Kotlin", "Java"],
+    domains=["매치메이킹", "실시간 게임 서버"],
+    notable_achievements=["매칭 대기 시간을 40% 줄인 큐 재설계", "피크 동시접속 50만 매칭 서버 무중단 운영"],
+    preferences=Preferences(locations=["서울"], visa_or_work_authorization=None,
+                            target_domains=["매치메이킹", "실시간 플랫폼"], target_roles=["백엔드 엔지니어"]),
+    dealbreakers=["프론트엔드 전담", "주니어 포지션"],
+    summary="Go 기반 매치메이킹 서버를 5년간 설계·운영한 백엔드 엔지니어. Redis·Kubernetes·PostgreSQL이 주력이다.",
+)
+
+
+def _match(eid: str, level: str, score: int, summary: str, tech: list[str], gaps: list[str], reason: str) -> Match:
+    return Match(external_id=eid, fit_level=level, score=score, gaps=gaps, summary=summary, tech_stack=tech,
+                 fit_reason=reason)
+
+
+MATCHES: dict[str, Match] = {m.external_id: m for m in [
+    _match("demo-toss-1", "strong", 90, "Go로 코어 서버를 개발하는 백엔드 포지션.", ["Go", "Redis", "Kubernetes"], [],
+           "주력 스택인 Go·Redis·Kubernetes가 공고 요구와 그대로 겹치고, 대규모 매칭 서버 무중단 운영 경험이 "
+           "대규모 트래픽 처리 요구에 직접 대응합니다. 연차도 5년 이상 조건에 맞습니다."),
+    _match("demo-toss-2", "good", 74, "결제 승인·정산 파이프라인을 만드는 백엔드 포지션.", ["Kotlin", "Go", "PostgreSQL"],
+           ["domain: 금융·결제 도메인 경험 없음"],
+           "Go와 PostgreSQL 경험이 핵심 요구와 맞고 분산 시스템 운영 경험도 유효하지만, 결제·정산 도메인 경험이 없어 "
+           "우대 요건에서 점수를 잃습니다."),
+    _match("demo-daangn-1", "strong", 92, "이웃 매칭 플랫폼의 백엔드를 설계·운영하는 포지션.", ["Go", "Redis", "Kubernetes"], [],
+           "매칭 로직의 지연과 공정성을 다루는 포지션으로, 매칭 대기 시간을 40% 줄인 큐 재설계 경험이 그대로 들어맞습니다. "
+           "Go·Redis·Kubernetes 스택도 동일합니다."),
+    _match("demo-daangn-2", "stretch", 56, "이벤트 파이프라인과 분석 저장소를 운영하는 데이터 플랫폼 포지션.",
+           ["Spark", "Airflow", "ClickHouse", "Python"],
+           ["framework: Spark·Airflow 경험 없음", "language: Python 배치 개발이 주력이 아님"],
+           "ClickHouse 운영 경험이 있어 저장소 쪽은 접점이 있지만, Spark·Airflow 기반 파이프라인과 Python 배치 개발이 "
+           "주력이 아니라 서류 리스크가 있습니다."),
+    _match("demo-kakao-1", "good", 70, "모바일 게임의 매치메이킹·랭킹 서버를 만드는 포지션.", ["Kotlin", "Spring", "Redis"],
+           ["language: Kotlin/Spring 필수, 지원자는 Go 주력"],
+           "게임 매치메이킹 도메인과 Redis 세션 관리 경험이 공고와 정확히 겹칩니다. 다만 Kotlin/Spring이 필수라 "
+           "언어 전환이 필요해 한 단계 낮췄습니다."),
+    _match("demo-kakao-2", "stretch", 52, "사내 Kubernetes 플랫폼과 관측 스택을 운영하는 인프라 포지션.",
+           ["Kubernetes", "Terraform", "Ansible"],
+           ["other: 애플리케이션 개발이 아닌 인프라 운영 중심", "framework: Terraform·Ansible 경험 없음"],
+           "Kubernetes 운영 경험은 맞지만 역할이 인프라 프로비저닝과 네트워크·스토리지 운영에 치우쳐 있어 "
+           "백엔드 개발 경력과는 거리가 있습니다."),
+    _match("demo-naver-1", "stretch", 58, "검색 색인·질의 서빙 플랫폼을 개발하는 백엔드 포지션.", ["Java", "Spring"],
+           ["language: Java/Spring 필수, 지원자는 Go 주력", "domain: 검색 도메인 경험 없음"],
+           "대용량 분산 저장소 운영 경험은 유효하지만 Java/Spring이 필수이고 검색 도메인 경험이 없어 "
+           "역할은 맞되 서류 통과 리스크가 큽니다."),
+    _match("demo-naver-2", "good", 72, "대규모 실시간 메시징 서버를 개발하는 백엔드 포지션.", ["Go", "Java", "WebSocket"],
+           ["domain: 메시징 서비스 경험 없음"],
+           "Go와 분산 시스템 설계 경험이 요구와 맞고, 실시간 게임 서버 운영 경험이 실시간 메시징 트래픽 처리에 "
+           "전이됩니다. 메시징 도메인 자체는 처음이라 good에 둡니다."),
+]}
+
+
+async def load_profile(repo: Repository) -> Profile:
+    return PROFILE
+
+
+async def judge(profile: Profile, postings: list[RawPosting]) -> tuple[list[Match], list[Any]]:
+    await asyncio.sleep(float(os.environ.get("DEMO_JUDGE_DELAY_S", DEMO_JUDGE_DELAY_S)))
+    return [MATCHES[p.external_id].model_copy() for p in postings], []
+
+
+async def logged_in(provider: str) -> bool:
+    return True
+
+
+def make_app() -> FastAPI:
+    set_fixed_now(FIXED_NOW)
+    tmp: Path | None = None
+
+    def temp_path(name: str) -> Path:
+        nonlocal tmp
+        tmp = tmp or Path(tempfile.mkdtemp(prefix="gethired-demo-"))
+        return tmp / name
+
+    db_path = Path(os.environ.get("DB_PATH") or temp_path("app.db"))
+    resume_dir = Path(os.environ.get("RESUME_DIR") or temp_path("resume"))
+
+    repo = Repository(db_path)
+    jobs = JobManager(repo, scrapers=dict(SCRAPERS), profile_loader=load_profile, judge_fn=judge)
+    app = create_app(repo, jobs, logged_in=logged_in, resume_dir=resume_dir)
+    app.state.db_path, app.state.resume_dir = db_path, resume_dir
+    print(f"demo mode: DB_PATH={db_path} RESUME_DIR={resume_dir}", file=sys.stderr)
+    if FRONTEND_DIST.exists():
+        app.mount("/", StaticFiles(directory=FRONTEND_DIST, html=True), name="frontend")
+    return app
+
+
+if os.environ.get("GETHIRED_DEMO") == "1":
+    app = make_app()