feat(local-stack): kjbox partner secret + fake quick version (v0.280.1) (#1206)

## Summary
Local-stack only (no prod impact). For mobile Phase 5 "Tonight": the
kjbox local stack points at gen's local stack for make-it.
- `scripts/local-stack.sh`: `KJBOX_PARTNER_SECRET` and
`DECIDE_GEN_PARTNER_SECRET` default to `local-stack-secret`, external
values win.
- Fake workers emit a quick version (`state_data.quick_version` ready +
`file_urls.quick.video_mp4`) for kjbox-sourced jobs, using prod's
`should_build_quick_version` gate and quick-version helpers.
`FAKE_WORKERS` is still refused in production.
- docs/TESTING.md § Local stack updated.

## Testing
`test_kjbox_partner_api.py`, `test_fake_workers.py`,
`test_kjbox_resolve_partner.py`, `test_fake_match_judge.py`: all pass.
Reviewed by a task reviewer (1 fix round).

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

https://claude.ai/code/session_013Bkasn6trBadg1Zb39vSVR

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Andrew Beveridge ☄️andClaude Opus 5.5 authored and GitHub committed 2026-10-22 02:06:01 -04:00
1 parent 6c53f0471a
commit 53bed95e76
6 files changed
+117 -2

No files matched your search

+30 -1
View File
@@ -23,6 +23,7 @@ from backend.services.fake_workers.config import FakeConfig, get_fake_config
from backend.services.fake_workers.lyrics import build_corrections, build_lrc
from backend.services.fake_workers.media import MediaSet, get_media
from backend.services.job_manager import JobManager
from backend.services.quick_version import service as quick
from backend.services.storage_service import StorageService
logger = logging.getLogger(__name__)
@@ -116,6 +117,27 @@ async def run_audio_download(job_id: str) -> bool:
# ---------------------------------------------------------------- audio separation
async def _emit_quick_version(job, job_manager: JobManager, storage: StorageService, media: MediaSet) -> None:
"""kjbox make-it jobs: write the same ``state_data.quick_version`` +
``file_urls.quick.video_mp4`` the real audio worker's quick-version thread does
(``services/quick_version``), using the tiny fixture mp4. Same gate as prod
(``should_build_quick_version``), so non-kjbox jobs are untouched."""
if not quick.should_build_quick_version(job):
return
job_id = job.job_id
quick.set_quick_state(job_manager, job_id, quick.STATUS_SEPARATING, started_at=quick._now_iso())
quick.set_quick_state(job_manager, job_id, quick.STATUS_RENDERING)
gcs_path = f"jobs/{job_id}/quick/quick.mp4"
await asyncio.to_thread(storage.upload_file, media.final_mp4, gcs_path)
job_manager.update_file_url(job_id, quick.FILE_CATEGORY, quick.FILE_KEY, gcs_path)
quick.set_quick_state(
job_manager, job_id, quick.STATUS_READY,
lyrics_tier="fake_workers", line_count=0,
duration_seconds=float(media.duration),
size_bytes=os.path.getsize(media.final_mp4), ready_at=quick._now_iso(),
)
async def run_audio(job_id: str) -> bool:
config = await _begin("audio", job_id)
from backend.workers.audio_worker import _transcode_review_stems, upload_separation_results
@@ -123,11 +145,18 @@ async def run_audio(job_id: str) -> bool:
from backend.workers.worker_logging import create_job_logger
job_manager, storage = JobManager(), StorageService()
if not _job_or_none(job_manager, job_id):
job = _job_or_none(job_manager, job_id)
if not job:
return False
job_log = create_job_logger(job_id, "audio")
media = await asyncio.to_thread(_media_for, config)
try:
await _emit_quick_version(job, job_manager, storage, media)
except Exception as e: # non-fatal, same as the real worker
logger.warning(f"[job:{job_id}] fake audio: quick version failed: {e}")
quick.set_quick_state(job_manager, job_id, quick.STATUS_FAILED, error=str(e)[:500])
job_manager.update_state_data(job_id, "audio_progress", {
"stage": "separating", "progress": 30, "message": "Separating audio (fake)",
})
+40
View File
@@ -492,3 +492,43 @@ class TestFakeSearchConfidence:
with open(FRONTEND_FIXTURE) as f:
assert json.load(f) == frontend_fixture()
# --------------------------------------------------------------------------- kjbox quick version
class TestKjboxQuickVersion:
def _run_audio(self, request_metadata):
from backend.services.fake_workers import pipeline
jm = MagicMock()
jm.get_job.return_value = SimpleNamespace(
job_id="job1", user_email="u@example.com", artist="A", title="T",
request_metadata=request_metadata, state_data={},
)
jm.advance_to_screens_if_ready = AsyncMock()
jm.resume_video_if_waiting_for_stems = AsyncMock()
storage = MagicMock()
media = MagicMock(final_mp4=__file__, duration=30)
with patch.object(pipeline, "JobManager", return_value=jm), \
patch.object(pipeline, "StorageService", return_value=storage), \
patch.object(pipeline, "_media_for", return_value=media), \
patch.object(pipeline, "get_fake_config", return_value=FakeConfig(step_delay_seconds=0)), \
patch("backend.workers.audio_worker.upload_separation_results", AsyncMock()), \
patch("backend.workers.audio_worker._transcode_review_stems", AsyncMock()), \
patch("backend.workers.screens_worker._analyze_backing_vocals", AsyncMock()), \
patch("backend.workers.worker_logging.create_job_logger"):
assert asyncio.run(pipeline.run("audio", "job1")) is True
return jm, storage
def test_fake_workers_emit_quick_version_for_kjbox_jobs(self):
jm, storage = self._run_audio({"client_id": "kjbox"})
jm.update_file_url.assert_called_once_with("job1", "quick", "video_mp4", "jobs/job1/quick/quick.mp4")
storage.upload_file.assert_called_once()
statuses = [c.args[2]["status"] for c in jm.update_state_data.call_args_list
if c.args[1] == "quick_version"]
assert statuses == ["separating", "rendering", "ready"]
def test_non_kjbox_jobs_get_no_quick_version(self):
jm, storage = self._run_audio({"client_id": "web"})
jm.update_file_url.assert_not_called()
assert not [c for c in jm.update_state_data.call_args_list if c.args[1] == "quick_version"]
+36
View File
@@ -774,3 +774,39 @@ class TestCatalogResolve:
assert client.post("/api/kjbox/catalog/resolve", json={"query": "x"}).status_code == 403
assert self._post(client, "").status_code == 422
assert self._post(client, " ").status_code == 422
def _local_stack_env(monkeypatch, **overrides):
import os
import subprocess
from pathlib import Path
script = Path(__file__).resolve().parents[2] / "scripts" / "local-stack.sh"
env = {k: v for k, v in os.environ.items()
if k not in ("KJBOX_PARTNER_SECRET", "DECIDE_GEN_PARTNER_SECRET")}
env.update(overrides)
out = subprocess.run([str(script), "env"], capture_output=True, text=True, check=True, env=env).stdout
return dict(line.split("=", 1) for line in out.splitlines() if "=" in line)
def test_kjbox_routes_accept_local_secret(monkeypatch):
"""With nothing set externally, local-stack.sh defaults KJBOX_PARTNER_SECRET to
local-stack-secret and the partner gate accepts exactly that value."""
from fastapi import HTTPException
env = _local_stack_env(monkeypatch)
local_secret = env["KJBOX_PARTNER_SECRET"]
assert local_secret == "local-stack-secret"
assert env["DECIDE_GEN_PARTNER_SECRET"] == "local-stack-secret"
monkeypatch.setattr(kjbox, "get_settings", lambda: SimpleNamespace(kjbox_partner_secret=local_secret))
assert kjbox.require_kjbox_partner(local_secret) == local_secret
with pytest.raises(HTTPException) as exc:
kjbox.require_kjbox_partner("wrong")
assert exc.value.status_code == 403
def test_local_stack_honours_external_partner_secrets(monkeypatch):
env = _local_stack_env(monkeypatch, KJBOX_PARTNER_SECRET="ext-kjbox", DECIDE_GEN_PARTNER_SECRET="ext-decide")
assert env["KJBOX_PARTNER_SECRET"] == "ext-kjbox"
assert env["DECIDE_GEN_PARTNER_SECRET"] == "ext-decide"
+8
View File
@@ -334,6 +334,14 @@ settings object in a unit test never turns it on.
| Postmark | console provider + captured outbox | `ConsoleEmailProvider` |
| Secret Manager, DeBounce, encoding VM | skipped | `get_secret`, `is_disposable_domain`, warmup |
**kjbox partner calls.** The stack exports `KJBOX_PARTNER_SECRET=local-stack-secret`
(and `DECIDE_GEN_PARTNER_SECRET`, same value) so a local kjbox stack can call
`/api/kjbox/*` with `X-Kjbox-Secret: local-stack-secret`. For jobs created with
`X-Client-Id: kjbox…` the fake audio worker also writes the real "quick version"
outputs (`state_data.quick_version` separating -> rendering -> ready, and
`file_urls.quick.video_mp4` from the fixture mp4), so `/api/jobs/{id}/download-urls`
lists `quick/video_mp4` and `/download/quick/video_mp4` streams it, like prod.
The audio worker reuses the real stem upload, OGG transcode and backing-vocals
analysis. The review preview video is the real local ffmpeg render. Startup
**refuses** `FAKE_WORKERS` in production (`validate_production_config`).
+1 -1
View File
@@ -1,6 +1,6 @@
[tool.poetry]
name = "karaoke-gen"
version = "0.280.0"
version = "0.280.1"
description = "Generate karaoke videos with synchronized lyrics. Handles the entire process from downloading audio and lyrics to creating the final video with title screens."
authors = ["Andrew Beveridge <andrew@beveridge.uk>"]
license = "MIT"
+2
View File
@@ -49,6 +49,8 @@ REVIEW_AUDIO_PROXY=1
MAX_SIGNUPS_PER_IP=100000
BOARD_MAX_SIGNUPS_PER_IP=100000
LOGIN_CODES_PER_IP_PER_HOUR=100000
KJBOX_PARTNER_SECRET=${KJBOX_PARTNER_SECRET:-local-stack-secret}
DECIDE_GEN_PARTNER_SECRET=${DECIDE_GEN_PARTNER_SECRET:-local-stack-secret}
POSTMARK_SERVER_TOKEN=
STRIPE_SECRET_KEY=
EOF