initial ytdlp worker

README.md

@@ -1,7 +1,9 @@
-build and run the docker container
-```
-api_token = [discord bot token]
--v [downloads]:/downloads
+v2 architecture draft: see `docs/architecture-v2.org`
+
+build and run the docker container
+```
+api_token = [discord bot token]
+-v [downloads]:/downloads
 -v [config]:/config
 ```
 config contains data to persist across container updates, i.e., unraid appdata, 

agents.md

@@ -0,0 +1,24 @@
+# agent rules
+
+## priorities
+- optimize for simplicity, boringness, and long-term maintainability
+- prefer minimal diffs; avoid refactors unless required for the active task
+
+## tech stack
+- python
+- file storage: json and csv, no sqlite or databases
+- assume local virtual env is available and accessible
+- do not add new dependencies unless explicitly approved; if unavoidable, document justification in the active task notes
+
+## workflow
+- work on ONE task at a time unless explicitly instructed otherwise
+- at the start of work, state the task id you are executing
+- do not start work unless a task id is specified; if missing, choose the earliest unchecked task and say so
+- propose incremental steps
+- always include basic tests for core logic
+- add assumptions and questions along-the-way to the ** notes section under the active task 
+- when you complete a task:
+  - mark it [X] in pm/tasks.org
+  - fill in evidence with commit hash + commands run
+  - never mark complete unless acceptance criteria are met
+  - include date and time (HH:MM)

default-yt-dlp.conf

@@ -1,11 +1,8 @@
-# yt-dlp config file (yt-dlp.conf or .config/yt-dlp/config)
---simulate
--f "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best"
---embed-chapters
---embed-info-json
---write-playlist-metafiles
-#--paths "{"home":"./downloads"}"
---download-archive "/config/archive.txt"
---restrict-filenames
---output "/downloads/%(uploader)s/%(playlist_title)s/%(playlist_index)s%(playlist_index& - )s%(title)s.%(ext)s"
-# --split-chapters
+# yt-dlp config file
+-f "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best"
+--embed-chapters
+--embed-info-json
+--write-playlist-metafiles
+--download-archive "/config/archive.txt"
+--restrict-filenames
+--output "/downloads/%(uploader)s/%(playlist_title)s/%(playlist_index)s%(playlist_index& - )s%(title)s.%(ext)s"

docs/architecture-v2.org

@@ -0,0 +1,248 @@
+#+TITLE: youdis v2 architecture
+#+DATE: [2026-03-31 Tue]
+#+VERSION: 3
+
+* Purpose
+Youdis v2 splits the current monolithic Discord bot into:
+- a private backend worker service that owns yt-dlp execution
+- thin chat adapters that translate user actions into backend requests
+
+The goal is to make downloader behavior inspectable, reusable, and easier to debug across multiple frontends without introducing queueing infrastructure or complex deployment.
+
+** Goals
+- Keep the backend transport-agnostic.
+- Preserve archive-first duplicate prevention via `archive.txt`.
+- Keep single-job semantics explicit.
+- Treat requester and origin metadata as informational, not authorization.
+- Make yt-dlp configuration understandable and debuggable.
+
+** Non-Goals
+- No backend auth or user membership logic.
+- No database, Redis, or external queue.
+- No multi-worker scheduling in v2.
+- No frontend-owned downloader logic.
+
+* Proposed Components
+** Backend worker service
+Owns:
+- request validation
+- single active job state
+- yt-dlp executable invocation
+- yt-dlp configuration selection and runtime argument construction
+- archive behavior
+- output path behavior
+- progress and final result events
+
+Does not own:
+- Discord slash-command parsing
+- chat formatting decisions
+- access control policy
+
+** Frontend adapters
+1. Discord
+2. Zulip
+3. XMPP
+
+Own:
+- command parsing
+- user-facing message formatting
+- transport-specific reply behavior
+- optional frontend-side gating if the deployment wants it
+
+Do not own:
+- yt-dlp option construction
+- archive checks
+- output path logic
+- job lifecycle rules
+
+* Initial Deployment Shape
+
+V2 should start as a single private process boundary with two layers:
+1. backend service process
+2. one Discord adapter process
+
+The backend is intended for private/local deployment. Trust comes from deployment topology and network placement, not backend auth.
+
+** Execution model
+The backend is a thin FastAPI wrapper around the `yt-dlp` executable, not a deep Python integration, unless proven necessary.
+
+Why this is the default:
+- keeps behavior closer to native `yt-dlp`
+- makes container debugging easier because commands can be reproduced manually
+- avoids reimplementing `yt-dlp` option parsing unless we truly need tighter integration
+
+This means the backend is primarily responsible for:
+- deciding when `yt-dlp` may run
+- constructing a safe effective command
+- supervising the subprocess while it is active
+- translating process outcomes into a small API contract
+
+** Backend Contract
+*** Request model
+Minimal fields:
+- `url`
+- `requester_id` optional
+- `requester_name` optional
+- `origin` optional
+- `requested_at` optional
+Only `url` affects downloader behavior in v2. The rest is passthrough metadata for logs and frontend context.
+
+*** Result states
+The backend should keep its external state model deliberately small:
+- `accepted`
+- `busy`
+- `running`
+- `completed`
+- `failed`
+- `cancelled`
+
+These states should be transport-agnostic, human-debuggable, and only distinct when a frontend would behave differently.
+
+Internal phases and details may be richer, but they should usually be carried as metadata rather than promoted to top-level states.
+
+Examples of detail fields that can travel alongside the small state model:
+- `phase=validating`
+- `phase=downloading`
+- `disposition=archive_hit`
+- `message=already in archive`
+- `result_path=/downloads/...`
+
+This keeps the API simple while still leaving room for useful operator-facing detail.
+
+*** Minimal endpoints
+The first backend seam should stay small:
+- `POST /jobs`
+- `GET /jobs/current`
+- `POST /jobs/current/cancel`
+- `GET /health`
+- `GET /version`
+
+Polling is the default integration model for v2. Streaming or push delivery is deferred unless a real frontend need appears.
+
+** Single-Job Semantics
+V2 explicitly supports one active job at a time.
+- If idle, the backend accepts a new job and marks it active.
+- If busy, the backend rejects the new request with a `busy` result.
+- Cancel is coarse and best-effort.
+- The backend clears active state when the job reaches `completed`, `failed`, or `cancelled`.
+
+This is a feature, not a limitation, for the initial service.
+
+* yt-dlp Configuration Ownership
+
+This is the most important v2 cleanup.
+
+The backend owns all yt-dlp invocation behavior. Frontends must not build `yt-dlp` commands or option dictionaries.
+
+** Config split
+
+Static settings belong in `default-yt-dlp.conf`:
+- archive path
+- output template
+- embedding and metadata preferences
+- stable format defaults
+- retry defaults
+
+Runtime settings belong in backend code:
+- target URL
+- config-file path, if explicitly set at launch
+- request-scoped flags or overrides
+- subprocess lifecycle and cancellation behavior
+- any values that must vary per request
+
+*** Merge rule
+The backend should invoke `yt-dlp` with the default config first, then apply a small set of explicit runtime overrides.
+
+If a runtime override conflicts with file-backed config, the override wins and the backend should log the effective value used.
+
+*** Debuggability requirement
+For each job, the backend should make it easy to inspect:
+
+- config file path used
+- effective `yt-dlp` command or key override arguments
+- final normalized job result
+
+This exists specifically because the current config behavior has been difficult to reason about.
+
+*** Config hygiene expectations
+
+The default config should be safe for real downloads in production-like use.
+
+That means test-only settings such as `--simulate` should not remain enabled in the default runtime path unless the backend intentionally supports an explicit dry-run mode.
+
+** Recommended Repo Shape
+One reasonable first cut:
+
+#+begin_quote
+youdis/
+  README.md
+  default-yt-dlp.conf
+  youdis/
+    __init__.py
+    main.py
+    models.py
+    adapters/
+      __init__.py
+      discord.py
+  docs/
+    architecture-v2.org
+#+end_quote
+
+Notes:
+
+- `main.py` owns the FastAPI app, active-job state, and `yt-dlp` subprocess lifecycle.
+- `models.py` owns request and response models.
+- `adapters/discord.py` becomes a thin client of the backend.
+
+** Example response shape
+
+One likely response shape for v1:
+
+#+begin_src json
+{
+  "state": "completed",
+  "disposition": "archive_hit",
+  "message": "already in archive",
+  "job_id": "abc123"
+}
+#+end_src
+
+And for an active job:
+
+#+begin_src json
+{
+  "state": "running",
+  "phase": "downloading",
+  "message": "downloading 3 of 9",
+  "job_id": "abc123"
+}
+#+end_src
+
+** Framework Recommendation
+
+FastAPI is the current recommendation for the backend seam.
+
+Why it fits:
+
+- typed request and response models help define the contract cleanly
+- built-in docs make local inspection easier during early iterations
+- it stays small enough for this service if we keep the surface area disciplined
+
+Why this is not a strong ideological choice:
+
+- Flask would also work if we decide the type/model ergonomics are not worth it
+- the important decision is keeping the seam small, not choosing a fashionable framework
+
+** Immediate Next Task
+
+`2.0.1` should implement the backend skeleton with just enough real behavior to prove the seam:
+
+- package/module layout
+- health and version endpoint
+- single active-job state holder
+- one submit-job path
+- one current-job status path
+- `yt-dlp` subprocess invocation using `default-yt-dlp.conf`
+- explicit runtime overrides for request URL and cancel behavior
+
+The Discord adapter should remain unchanged until that backend skeleton can accept a job and report status coherently.

pm/task-sample.org

@@ -2,15 +2,17 @@
 #+updated: [2026-03-31 Tue 16:03]
 
 Use the template below, which should be a top-level org-mode header.
+A sample task is below the template
 
-* [ ] M.m.m: Task Title (# commits)
+* [ ] M.m.m: Task Title (<estimated # of commits>)
 description of the task
 ** pm notes: amplifying information
 
 ** Acceptance Criteria
 1. Criterion
    - expanded data
-2. Criterion 
+2. Criterion
+3f. Criterion added after initial task completion   
 
 ** evidence
 - commit: abc123, bcd234
@@ -19,3 +21,61 @@ description of the task
 
 ** notes    
 - explanation of work done, decisions made, reasoning
+
+  
+* [ ] 2.0.1: build backend yt-dlp worker (3)
+create the minimal backend/service skeleton and establish a working yt-dlp baseline with clean hooks for future frontends
+** pm notes
+- foundation; don't need the full finished service here, just the basic shape plus enough real yt-dlp execution to validate the seam and build on it.
+- keep single-job semantics
+- prioritize inspectable behavior over polish
+
+** Acceptance Criteria
+1. create the backend/service skeleton
+   - app/module layout exists
+   - core request path is stubbed or minimally working
+2. establish a working yt-dlp baseline
+   - archive behavior is preserved
+   - output path behavior is preserved or intentionally updated
+   - use yt-dlp .conf and set reasonable default
+3. expose basic hooks/interfaces for future frontends
+   - submit/request path exists
+   - status/progress hook exists
+   - basic health/version visibility exists
+4f. print env vars to stdout on fastapi launch
+   - repo_root
+   - default_config
+   - ytdlp_executable
+5f. create ytdlp conf to facilitate tests     
+** evidence
+- commit:
+- tests:
+  1. `python3 -m py_compile ./youdis/main.py ./youdis/models.py ./youdis/adapters/__init__.py ./youdis/adapters/discord.py`
+  2. `python3 -m uvicorn youdis.main:app --host 127.0.0.1 --port 8000`
+  3. `sudo curl -L https://github.com/yt-dlp/yt-dlp/releases/download/2026.03.17/yt-dlp -o /usr/local/bin/yt-dlp`
+  4. `sudo chmod +x /usr/local/bin/yt-dlp`
+  5. `yt-dlp --version`
+  6. `curl http://127.0.0.1:8000/health`
+  7. `curl http://127.0.0.1:8000/version`
+  8. `curl -X POST http://127.0.0.1:8000/jobs -H 'content-type: application/json' -d '{"url":"https://www.youtube.com/watch?v=dQw4w9WgXcQ"}'`
+  9. `curl http://127.0.0.1:8000/jobs/current`
+  10. if testing in container: `docker build -t youdis:v2 .`
+  11. if testing in container: `docker run --rm -p 8000:8000 -v [config]:/config -v [downloads]:/downloads youdis:v2`
+  :OUTPUT_STEP1-9:
+  user@paladin:~/proj/youdis$ curl http://127.0.0.1:8000/health
+{"status":"ok"}user@paladin:~/proj/youdis$
+user@paladin:~/proj/youdis$ curl http://127.0.0.1:8000/version
+{"version":"20250829-ec72c56","active_job":false}user@paladin:~/proj/youdis$
+user@paladin:~/proj/youdis$ curl -X POST http://127.0.0.1:8000/jobs -H 'content-type: application/json' -d '{"url":"https://www.youtube.com/watch?v=3i72yY_LaW4"}'
+{"job_id":"cc85165e-d906-4eee-864f-1a398b6de2e0","state":"accepted","url":"https://www.youtube.com/watch?v=3i72yY_LaW4","message":"accepted","phase":"queued","disposition":null,"requester_id":null,"requester_name":null,"origin":null,"result_path":null,"command":[],"returncode":null,"created_at":"2026-04-01T00:44:35.657196","updated_at":"2026-04-01T00:44:35.657198"}user@paladin:~/proj/youdis$ curl http://127.0.0.1:8000/jobs/current
+{"active":false,"job":{"job_id":"cc85165e-d906-4eee-864f-1a398b6de2e0","state":"failed","url":"https://www.youtube.com/watch?v=3i72yY_LaW4","message":"ERROR: unable to create directory [Errno 13] Permission denied: '/downloads'","phase":null,"disposition":null,"requester_id":null,"requester_name":null,"origin":null,"result_path":null,"command":["yt-dlp","--config-locations","/home/user/proj/youdis/default-yt-dlp.conf","https://www.youtube.com/watch?v=3i72yY_LaW4"],"returncode":1,"created_at":"2026-04-01T00:44:35.657196","updated_at":"2026-03-31T20:44:36.653353"}}user@paladin:~/proj/youdis$
+  :END:
+- datetime: [2026-03-31 Tue 20:45]
+
+** notes
+- validate `yt-dlp` subprocess invocation in-container; not verifiable in the current shell because `yt-dlp` is not installed here
+- confirm `--config-locations` behavior against the installed `yt-dlp` version during integration testing
+- current backend scaffold is not yet wired into `dockerfile` or `run-youdis.sh`
+- archive-hit and result-path parsing currently depend on `yt-dlp` stdout text patterns, so treat them as provisional until integration-tested
+
+  

pm/tasks-v2.org

@@ -0,0 +1,165 @@
+#+title: Task Log
+#+updated: [2026-03-31 Tue 16:03]
+#+startup: overview
+
+* youdis v2 goals:
+1. Separate backend from frontend
+2. Offload auth
+3. Ensure auto nightly builds
+4. Default output format supports plex browsing youtube channels as "tv shows"
+5. Facilitate multiple GUI inbounds: Discord, Zulip, XMPP
+
+* [X] 2.0.0: define architecture (2-4)
+define the target architecture for a private backend yt-dlp worker with thin chat frontends
+** pm notes:
+- keep this iterative. the point is to choose the shape and seam, not prematurely implement infra. likely decisions include backend framework, request/status model, and how thin the discord shim should be.
+- goal is simple, private, maintainable deployment
+- avoid auth, queues, or persistence beyond clear & immediate needs
+
+** Acceptance Criteria
+1. document the target architecture at a high level
+   - backend owns yt-dlp execution and job state
+   - frontends own chat-specific UX
+2. identify key decisions still open
+   - backend choice
+   - service seam/endpoints
+   - status/progress model
+3. capture enough structure to begin implementation
+   - repo/component layout is sketched
+   - next implementation task is unblocked
+
+** evidence
+- commit: 0ed16ec
+- tests: n/a
+- datetime: [2026-03-31 Tue 18:48]
+
+** notes
+- first architecture draft captured in `docs/architecture-v2.org`
+
+* [ ] 2.0.1: build backend yt-dlp worker (3)
+create the minimal backend/service skeleton and establish a working yt-dlp baseline with clean hooks for future frontends
+** pm notes
+- foundation; don't need the full finished service here, just the basic shape plus enough real yt-dlp execution to validate the seam and build on it.
+- keep single-job semantics
+- prioritize inspectable behavior over polish
+
+** Acceptance Criteria
+1. create the backend/service skeleton
+   - app/module layout exists
+   - core request path is stubbed or minimally working
+2. establish a working yt-dlp baseline
+   - archive behavior is preserved
+   - output path behavior is preserved or intentionally updated
+   - use yt-dlp .conf and set reasonable default
+3. expose basic hooks/interfaces for future frontends
+   - submit/request path exists
+   - status/progress hook exists
+   - basic health/version visibility exists
+4f.      
+
+** evidence
+- commit:
+- tests:
+  1. `python3 -m py_compile ./youdis/main.py ./youdis/models.py ./youdis/adapters/__init__.py ./youdis/adapters/discord.py`
+  2. `python3 -m uvicorn youdis.main:app --host 127.0.0.1 --port 8000`
+  3. `sudo curl -L https://github.com/yt-dlp/yt-dlp/releases/download/2026.03.17/yt-dlp -o /usr/local/bin/yt-dlp`
+  4. `sudo chmod +x /usr/local/bin/yt-dlp`
+  5. `yt-dlp --version`
+  6. `curl http://127.0.0.1:8000/health`
+  7. `curl http://127.0.0.1:8000/version`
+  8. `curl -X POST http://127.0.0.1:8000/jobs -H 'content-type: application/json' -d '{"url":"https://www.youtube.com/watch?v=dQw4w9WgXcQ"}'`
+  9. `curl http://127.0.0.1:8000/jobs/current`
+  10. if testing in container: `docker build -t youdis:v2 .`
+  11. if testing in container: `docker run --rm -p 8000:8000 -v [config]:/config -v [downloads]:/downloads youdis:v2`
+  :OUTPUT_STEP1-9:
+  user@paladin:~/proj/youdis$ curl http://127.0.0.1:8000/health
+{"status":"ok"}user@paladin:~/proj/youdis$
+user@paladin:~/proj/youdis$ curl http://127.0.0.1:8000/version
+{"version":"20250829-ec72c56","active_job":false}user@paladin:~/proj/youdis$
+user@paladin:~/proj/youdis$ curl -X POST http://127.0.0.1:8000/jobs -H 'content-type: application/json' -d '{"url":"https://www.youtube.com/watch?v=3i72yY_LaW4"}'
+{"job_id":"cc85165e-d906-4eee-864f-1a398b6de2e0","state":"accepted","url":"https://www.youtube.com/watch?v=3i72yY_LaW4","message":"accepted","phase":"queued","disposition":null,"requester_id":null,"requester_name":null,"origin":null,"result_path":null,"command":[],"returncode":null,"created_at":"2026-04-01T00:44:35.657196","updated_at":"2026-04-01T00:44:35.657198"}user@paladin:~/proj/youdis$ curl http://127.0.0.1:8000/jobs/current
+{"active":false,"job":{"job_id":"cc85165e-d906-4eee-864f-1a398b6de2e0","state":"failed","url":"https://www.youtube.com/watch?v=3i72yY_LaW4","message":"ERROR: unable to create directory [Errno 13] Permission denied: '/downloads'","phase":null,"disposition":null,"requester_id":null,"requester_name":null,"origin":null,"result_path":null,"command":["yt-dlp","--config-locations","/home/user/proj/youdis/default-yt-dlp.conf","https://www.youtube.com/watch?v=3i72yY_LaW4"],"returncode":1,"created_at":"2026-04-01T00:44:35.657196","updated_at":"2026-03-31T20:44:36.653353"}}user@paladin:~/proj/youdis$
+  :END:
+- datetime: [2026-03-31 Tue 20:45]
+
+** notes
+- validate `yt-dlp` subprocess invocation in-container; not verifiable in the current shell because `yt-dlp` is not installed here
+- confirm `--config-locations` behavior against the installed `yt-dlp` version during integration testing
+- current backend scaffold is not yet wired into `dockerfile` or `run-youdis.sh`
+- archive-hit and result-path parsing currently depend on `yt-dlp` stdout text patterns, so treat them as provisional until integration-tested
+
+* [ ] 2.0.2: update discord bot to use new backend (3)
+update the discord bot into a thin frontend that talks to the backend and verify the flow end to end
+** pm notes
+- this is the first real frontend proof. once this works cleanly, zulip/xmpp should mostly be adapter work rather than downloader rewrites.
+- keep discord logic thin; no auth
+- do not duplicate yt-dlp behavior in the bot
+
+** Acceptance Criteria
+1. discord bot submits requests to backend
+   - command/input handling works
+   - acceptance/busy/failure responses are clear
+2. discord bot relays useful backend status
+   - progress reporting works at a basic level
+   - completion/failure/skipped outcomes are surfaced
+3. backend-discord flow is tested end to end
+   - valid request path tested
+   - busy or conflict behavior tested
+   - failure path tested
+
+** evidence
+- commit:
+- tests:
+- datetime:
+
+** notes
+
+* [ ] 2.0.3: remove deprecated discord-bot functionality (2)
+delete or retire legacy bot behaviors that no longer fit once the backend split is in place
+** pm notes
+- only remove this after the new path works. this is cleanup, not pioneering work.
+- favor deletion over compatibility shims
+- keep operator controls only if still useful
+
+** Acceptance Criteria
+1. remove obsolete auth/user-management behavior
+   - old user persistence and commands are removed
+   - backend-facing flow no longer depends on them
+2. remove obsolete downloader/runtime logic from bot
+   - bot no longer owns yt-dlp execution
+   - dead code paths are deleted
+3. leave the bot in a coherent state
+   - remaining commands reflect actual supported behavior
+   - deprecated artifacts are clearly removed or marked
+
+** evidence
+- commit:
+- tests:
+- datetime:
+
+** notes
+
+* [ ] 2.0.5: fix automation and build pipeline (3)
+repair and simplify the build/update/deploy path so it matches the new backend-plus-frontend structure
+** pm notes
+- this should come after architecture and discord integration stabilize. no point polishing the pipeline for the wrong shape.
+- optimize for simple manual ops first
+- stop here after pipeline is sane
+  
+** Acceptance Criteria
+1. align build artifacts with the new structure
+   - docker/build scripts reflect current components
+   - runtime assumptions are consistent
+2. review old automation artifacts
+   - stale runner/update/restart logic is removed or updated
+   - manual update/rebuild flow is clear
+3. confirm deployment path works
+   - local or unraid deployment is validated
+   - pipeline is understandable enough to maintain
+
+** evidence
+- commit:
+- tests:
+- datetime:
+
+** notes

youdis/__init__.py

@@ -0,0 +1 @@
+"""Youdis v2 backend package."""

youdis/adapters/__init__.py

@@ -0,0 +1 @@
+"""Frontend adapters for the youdis backend."""

youdis/adapters/discord.py

@@ -0,0 +1 @@
+"""Discord adapter placeholder for the v2 backend."""

youdis/main.py

@@ -0,0 +1,255 @@
+import asyncio
+from asyncio.subprocess import PIPE, STDOUT
+from collections import deque
+from dataclasses import dataclass, field
+from datetime import datetime
+from os import getenv
+from pathlib import Path
+from uuid import uuid4
+
+from fastapi import FastAPI, HTTPException
+
+from .models import CurrentJobResponse, HealthResponse, JobRequest, JobStatus, VersionResponse
+
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+DEFAULT_CONFIG = REPO_ROOT / "default-yt-dlp.conf"
+VERSION_FILE = REPO_ROOT / "youdis-version.txt"
+YTDLP_EXECUTABLE = getenv("YOUDIS_YTDLP_EXECUTABLE", "yt-dlp")
+
+
+@dataclass
+class ManagedJob:
+    status: JobStatus
+    process: asyncio.subprocess.Process | None = None
+    task: asyncio.Task | None = None
+    cancel_requested: bool = False
+    output_lines: deque[str] = field(default_factory=lambda: deque(maxlen=25))
+
+
+app = FastAPI(title="youdis", version="2")
+job_lock = asyncio.Lock()
+active_job: ManagedJob | None = None
+last_job: JobStatus | None = None
+
+
+def now_utc() -> datetime:
+    return datetime.now()
+
+
+def read_version() -> str:
+    if VERSION_FILE.exists():
+        return VERSION_FILE.read_text().strip()
+    return "unknown"
+
+
+def build_ytdlp_command(request: JobRequest) -> list[str]:
+    return [
+        YTDLP_EXECUTABLE,
+        "--config-locations",
+        str(DEFAULT_CONFIG),
+        request.url,
+    ]
+
+
+def clone_status(status: JobStatus) -> JobStatus:
+    return JobStatus(**status.model_dump())
+
+
+def update_status(job: ManagedJob, **changes: object) -> None:
+    for key, value in changes.items():
+        setattr(job.status, key, value)
+    job.status.updated_at = now_utc()
+
+
+def classify_output_line(job: ManagedJob, line: str) -> None:
+    if not line:
+        return
+
+    job.output_lines.append(line)
+    message = line.strip()
+    if not message:
+        return
+
+    lowered = message.lower()
+    if "has already been recorded in the archive" in lowered:
+        update_status(
+            job,
+            disposition="archive_hit",
+            phase="downloading",
+            message="already in archive",
+        )
+        return
+
+    if "[download]" in lowered:
+        update_status(job, phase="downloading", message=message)
+        if "destination:" in lowered:
+            result_path = message.split(":", 1)[1].strip()
+            update_status(job, result_path=result_path)
+        return
+
+    if "merging formats into" in lowered:
+        result_path = message.split("into", 1)[1].strip().strip('"')
+        update_status(job, phase="postprocessing", message=message, result_path=result_path)
+        return
+
+    update_status(job, message=message)
+
+
+async def finalize_job(job: ManagedJob, returncode: int) -> None:
+    disposition = job.status.disposition
+    if job.cancel_requested:
+        state = "cancelled"
+        message = "cancelled"
+    elif returncode == 0 and disposition == "archive_hit":
+        state = "completed"
+        message = "already in archive"
+    elif returncode == 0:
+        state = "completed"
+        message = job.status.message or "completed"
+    else:
+        state = "failed"
+        message = job.status.message or f"yt-dlp exited with code {returncode}"
+
+    update_status(job, state=state, phase=None, returncode=returncode, message=message)
+
+    global active_job, last_job
+    async with job_lock:
+        if active_job is job:
+            active_job = None
+        last_job = clone_status(job.status)
+
+
+async def run_job(job: ManagedJob, request: JobRequest) -> None:
+    command = build_ytdlp_command(request)
+    update_status(
+        job,
+        state="running",
+        phase="starting",
+        message="starting yt-dlp",
+        command=command,
+    )
+
+    try:
+        if not DEFAULT_CONFIG.exists():
+            update_status(
+                job,
+                state="failed",
+                phase=None,
+                message=f"default config not found: {DEFAULT_CONFIG}",
+                returncode=78,
+            )
+            await finalize_job(job, 78)
+            return
+
+        process = await asyncio.create_subprocess_exec(
+            *command,
+            stdout=PIPE,
+            stderr=STDOUT,
+        )
+    except FileNotFoundError:
+        update_status(
+            job,
+            state="failed",
+            phase=None,
+            message="yt-dlp executable not found",
+            returncode=127,
+        )
+        await finalize_job(job, 127)
+        return
+
+    try:
+        job.process = process
+        update_status(job, phase="running", message="yt-dlp running")
+
+        assert process.stdout is not None
+        while True:
+            line = await process.stdout.readline()
+            if not line:
+                break
+            classify_output_line(job, line.decode(errors="replace").strip())
+
+        returncode = await process.wait()
+        await finalize_job(job, returncode)
+    except Exception as exc:
+        update_status(
+            job,
+            state="failed",
+            phase=None,
+            message=f"backend runner error: {exc}",
+            returncode=1,
+        )
+        await finalize_job(job, 1)
+
+
+async def create_job(request: JobRequest) -> JobStatus:
+    global active_job
+    async with job_lock:
+        if active_job is not None:
+            busy_job = active_job.status
+            return JobStatus(
+                job_id=busy_job.job_id,
+                state="busy",
+                url=request.url,
+                message=f"busy with {busy_job.url}",
+                requester_id=request.requester_id,
+                requester_name=request.requester_name,
+                origin=request.origin,
+            )
+
+        status = JobStatus(
+            job_id=str(uuid4()),
+            state="accepted",
+            url=request.url,
+            message="accepted",
+            phase="queued",
+            requester_id=request.requester_id,
+            requester_name=request.requester_name,
+            origin=request.origin,
+        )
+        managed_job = ManagedJob(status=status)
+        managed_job.task = asyncio.create_task(run_job(managed_job, request))
+        active_job = managed_job
+        return clone_status(status)
+
+
+@app.get("/health", response_model=HealthResponse)
+async def health() -> HealthResponse:
+    return HealthResponse(status="ok")
+
+
+@app.get("/version", response_model=VersionResponse)
+async def version() -> VersionResponse:
+    return VersionResponse(version=read_version(), active_job=active_job is not None)
+
+
+@app.get("/jobs/current", response_model=CurrentJobResponse)
+async def current_job() -> CurrentJobResponse:
+    async with job_lock:
+        if active_job is not None:
+            return CurrentJobResponse(active=True, job=clone_status(active_job.status))
+        if last_job is not None:
+            return CurrentJobResponse(active=False, job=clone_status(last_job))
+    return CurrentJobResponse(active=False, job=None)
+
+
+@app.post("/jobs", response_model=JobStatus)
+async def submit_job(request: JobRequest) -> JobStatus:
+    return await create_job(request)
+
+
+@app.post("/jobs/current/cancel", response_model=JobStatus)
+async def cancel_current_job() -> JobStatus:
+    async with job_lock:
+        if active_job is None:
+            raise HTTPException(status_code=404, detail="no active job")
+        job = active_job
+        if job.process is None:
+            update_status(job, message="cancel requested before yt-dlp started")
+            job.cancel_requested = True
+            return clone_status(job.status)
+
+        job.cancel_requested = True
+        update_status(job, message="cancel requested", phase="running")
+        job.process.terminate()
+        return clone_status(job.status)

youdis/models.py

@@ -0,0 +1,46 @@
+from datetime import datetime
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+JobState = Literal["accepted", "busy", "running", "completed", "failed", "cancelled"]
+
+
+class JobRequest(BaseModel):
+    url: str
+    requester_id: str | None = None
+    requester_name: str | None = None
+    origin: str | None = None
+    requested_at: datetime | None = None
+
+
+class JobStatus(BaseModel):
+    job_id: str
+    state: JobState
+    url: str
+    message: str | None = None
+    phase: str | None = None
+    disposition: str | None = None
+    requester_id: str | None = None
+    requester_name: str | None = None
+    origin: str | None = None
+    result_path: str | None = None
+    command: list[str] = Field(default_factory=list)
+    returncode: int | None = None
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    updated_at: datetime = Field(default_factory=datetime.utcnow)
+
+
+class CurrentJobResponse(BaseModel):
+    active: bool
+    job: JobStatus | None = None
+
+
+class HealthResponse(BaseModel):
+    status: Literal["ok"]
+
+
+class VersionResponse(BaseModel):
+    version: str
+    active_job: bool