mirror of
https://github.com/pewdiepie-archdaemon/odysseus.git
synced 2026-10-30 17:52:26 +01:00
Alexandre Teixeira
6037707430
Ensure the native candidate that passed the health check is prioritized and executed when an earlier broken candidate exists on PATH. Reconcile Odysseus-owned shims safely, invalidate command hash cache, and verify launchability rather than command existence before serve dispatch. Fixes #6079
1355 lines
58 KiB
Python
1355 lines
58 KiB
Python
import os
|
|
import subprocess
|
|
from pathlib import Path
|
|
import pytest
|
|
from core.platform_compat import find_bash, git_bash_path
|
|
from routes.cookbook_helpers import (
|
|
ODYSSEUS_LLAMA_SHIM_MARKER,
|
|
_append_llama_server_shim_definition_lines,
|
|
_append_llama_server_shim_reconciliation_lines,
|
|
_append_llama_server_finalization_lines,
|
|
)
|
|
|
|
from tests.helpers.stylesheets import app_css
|
|
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
|
|
|
|
def _read(rel_path: str) -> str:
|
|
return (ROOT / rel_path).read_text(encoding="utf-8")
|
|
|
|
|
|
def test_backend_status_treats_download_exit_zero_as_completed():
|
|
source = _read("routes/cookbook_routes.py")
|
|
|
|
assert "exit_match = re.search(r\"=== process exited with code\\s+(-?\\d+)\"" in source
|
|
assert "elif has_exit and task_type == \"download\":" in source
|
|
assert "status = \"completed\" if exit_code == 0 else \"error\"" in source
|
|
|
|
|
|
def test_background_status_poll_reconciles_into_local_tasks():
|
|
source = _read("static/js/cookbookRunning.js")
|
|
|
|
assert "const statusById = new Map(tasks.map(t => [t.session_id, t]));" in source
|
|
assert "const completedByOutput = depDone || downloadDone;" in source
|
|
assert "const nextStatus = completedByOutput" in source
|
|
assert "live.status === 'completed'" in source
|
|
assert "? 'done'" in source
|
|
assert ": (live.status === 'error'" in source
|
|
assert "? 'error'" in source
|
|
assert "_saveTasks(localTasks);" in source
|
|
assert "completedDeps.forEach(t => _refreshDepsAfterInstall(t));" in source
|
|
|
|
|
|
def test_windows_session_commands_use_shared_powershell_wrapper_and_local_log_dir():
|
|
source = _read("static/js/cookbookRunning.js")
|
|
|
|
assert "const host = task.remoteHost;" in source
|
|
assert "host ? '$env:TEMP\\\\odysseus-sessions' : '$env:TEMP\\\\odysseus-tmux'" in source
|
|
assert "function _winPowerShellCmd(task, ps)" in source
|
|
assert "const command = `powershell -Command \"${ps}\"`;" in source
|
|
assert "if (!host) return command;" in source
|
|
assert "return `ssh ${_sshPrefix(_getPort(task))}${host} ${_shQuote(command)}`;" in source
|
|
|
|
|
|
def test_dep_install_success_recognized_from_exit_sentinel():
|
|
"""A pip dependency install reports success via the runner's exit-0
|
|
sentinel / pip's "Successfully installed" line, not the HuggingFace
|
|
download markers. The shared helper must key off those, so an install
|
|
whose tmux pane is gone isn't misread as crashed."""
|
|
source = _read("static/js/cookbookRunning.js")
|
|
|
|
assert "function _depInstallSucceeded(output) {" in source
|
|
assert "=== Process exited with code" in source
|
|
assert "Successfully installed" in source
|
|
|
|
|
|
def test_session_gone_heuristic_honors_dep_install_success():
|
|
"""The reconnect loop's session-gone branch (download tasks need an HF
|
|
marker to look successful) must also accept a finished dependency install,
|
|
otherwise a clean pip install with no HF markers is marked crashed."""
|
|
source = _read("static/js/cookbookRunning.js")
|
|
|
|
assert "const depInstallSucceeded = !!task.payload?._dep && _depInstallSucceeded(lastOutput);" in source
|
|
# Whitespace-normalized so the check survives line-wrapping/formatting while
|
|
# still proving the invariant: a finished dependency install short-circuits
|
|
# looksSuccessful ahead of the download/serve branch.
|
|
normalized = " ".join(source.split())
|
|
assert (
|
|
"const looksSuccessful = depInstallSucceeded "
|
|
"|| (task.type === 'download'"
|
|
) in normalized
|
|
|
|
|
|
def test_background_poll_recovers_done_for_stopped_dependency_install():
|
|
"""When the backend reports a finished dependency install as "stopped"
|
|
(its pip package is never in the HF cache the dead-session check inspects),
|
|
the reconciler must recover "done" from the retained output instead of
|
|
downgrading the card to crashed."""
|
|
source = _read("static/js/cookbookRunning.js")
|
|
|
|
assert "const combinedOutput = `${task.output || ''}\\n${live.output_tail || ''}`;" in source
|
|
assert "const depDone = !!task.payload?._dep && _depInstallSucceeded(combinedOutput);" in source
|
|
assert "(depDone || downloadDone) ? 'done' : (task.type === 'download' ? 'crashed' : 'stopped')" in source
|
|
|
|
|
|
def test_background_poll_recovers_done_for_completed_download():
|
|
"""When the backend reports a finished model download as "stopped" (its
|
|
tmux pane is gone after DOWNLOAD_OK, so the dead-session check can miss the
|
|
landed snapshot), the reconciler must recover "done" from the terminal
|
|
DOWNLOAD_OK sentinel instead of downgrading the card to crashed. The
|
|
background poll keys off DOWNLOAD_OK only (not the "/snapshots/" path, which
|
|
can appear mid-stream for multi-file downloads)."""
|
|
source = _read("static/js/cookbookRunning.js")
|
|
|
|
normalized = " ".join(source.split())
|
|
assert (
|
|
"const downloadDone = task.type === 'download' "
|
|
"&& String(combinedOutput || '').includes('DOWNLOAD_OK');"
|
|
) in normalized
|
|
|
|
|
|
def test_running_tab_render_disposes_card_owned_work_before_rebuild():
|
|
source = _read("static/js/cookbookRunning.js")
|
|
|
|
assert "function _disposeTaskCard(el) {" in source
|
|
assert "el._abort.abort()" in source
|
|
assert "clearInterval(el._uptimeInterval)" in source
|
|
assert "body.querySelectorAll('.cookbook-task').forEach(_disposeTaskCard);" in source
|
|
|
|
|
|
def test_existing_download_card_uses_finished_label_for_done_and_completed():
|
|
source = _read("static/js/cookbookRunning.js")
|
|
|
|
assert "const isDoneDl = _isFinishedDownload(task.status, task.type);" in source
|
|
assert source.count("const isDoneDl = _isFinishedDownload(task.status, task.type);") == 1
|
|
|
|
|
|
def test_background_monitor_requests_have_timeouts():
|
|
source = _read("static/js/cookbookRunning.js")
|
|
|
|
assert "function _fetchWithTimeout(input, init = {}, timeoutMs = 15000)" in source
|
|
assert "const res = await _fetchWithTimeout('/api/cookbook/tasks/status'" in source
|
|
assert "_fetchWithTimeout('/api/cookbook/state'" in source
|
|
assert "_fetchWithTimeout('/api/model-endpoints/probe-local'" in source
|
|
|
|
|
|
def test_stale_task_self_heal_is_single_flight_and_bounded():
|
|
source = _read("static/js/cookbookRunning.js")
|
|
|
|
assert "let _selfHealInFlight = null;" in source
|
|
assert "async function _selfHealStaleTasksImpl(opts = {})" in source
|
|
assert "if (_selfHealInFlight) return _selfHealInFlight;" in source
|
|
assert "_fetchWithTimeout('/api/shell/exec'" in source
|
|
|
|
|
|
def test_cookbook_state_sync_is_single_flight():
|
|
source = _read("static/js/cookbookRunning.js")
|
|
|
|
assert "let _syncFromServerInFlight = null;" in source
|
|
assert "async function _syncFromServerImpl()" in source
|
|
assert "if (_syncFromServerInFlight) return _syncFromServerInFlight;" in source
|
|
assert "pending.then(clearPending, clearPending);" in source
|
|
assert "const tracked = run.finally(() =>" in source
|
|
|
|
|
|
def test_cookbook_state_sync_requests_are_bounded():
|
|
source = _read("static/js/cookbookRunning.js")
|
|
|
|
assert "_fetchWithTimeout('/api/cookbook/state', { credentials: 'same-origin' }, 15000)" in source
|
|
assert "_fetchWithTimeout('/api/cookbook/state', {" in source
|
|
assert "}, 15000);" in source
|
|
assert source.count("fetch(") == 1 # the helper's own underlying request
|
|
|
|
|
|
def test_dependency_probe_cache_is_scoped_and_invalidated_after_install():
|
|
source = _read("routes/shell_routes.py")
|
|
|
|
assert "_PACKAGE_STATUS_CACHE" in source
|
|
assert "package_cache_key = (" in source
|
|
assert "(host or \"\").strip()" in source
|
|
assert "(venv or \"\").strip()" in source
|
|
assert "_PACKAGE_STATUS_CACHE[package_cache_key]" in source
|
|
assert "_PACKAGE_STATUS_CACHE_MAX = 64" in source
|
|
assert "oldest_key = min(_PACKAGE_STATUS_CACHE" in source
|
|
assert "_PACKAGE_STATUS_CACHE.clear()" in source
|
|
|
|
|
|
def test_terminal_download_status_skips_remote_cache_probes():
|
|
source = _read("routes/cookbook_routes.py")
|
|
|
|
assert "_persisted_terminal = _task_status in" in source
|
|
assert "or (not _persisted_terminal and _download_cache_incomplete(" in source
|
|
assert "and not _persisted_terminal\n and not download_has_incomplete_evidence" in source
|
|
|
|
|
|
def test_download_start_has_concurrent_click_guard():
|
|
source = _read("static/js/cookbookDownload.js")
|
|
|
|
assert "const _downloadStartsInFlight = new Set();" in source
|
|
assert "_downloadStartsInFlight.has(startKey)" in source
|
|
assert "_downloadStartsInFlight.add(startKey);" in source
|
|
assert "_downloadStartsInFlight.delete(startKey);" in source
|
|
|
|
|
|
def test_dependency_scan_only_latest_response_can_render():
|
|
source = _read("static/js/cookbook.js")
|
|
|
|
assert "let _dependenciesFetchId = 0;" in source
|
|
assert "const fetchId = ++_dependenciesFetchId;" in source
|
|
assert "if (fetchId !== _dependenciesFetchId) return;" in source
|
|
assert source.count("if (fetchId !== _dependenciesFetchId) return;") >= 2
|
|
|
|
|
|
def test_dependency_refresh_preserves_same_target_rows():
|
|
source = _read("static/js/cookbook.js")
|
|
|
|
assert "const preserveRows = !!list.querySelector('.cookbook-dep-row')" in source
|
|
assert "list.dataset.cookbookDepsScanSig === scanSig" in source
|
|
assert "Refreshing packages…" in source
|
|
assert "list.prepend(loading);" in source
|
|
assert "list.replaceChildren(loading);" in source
|
|
|
|
|
|
def test_dependency_probe_has_bounded_http_request_and_status_error():
|
|
source = _read("static/js/cookbook.js")
|
|
|
|
assert "let _dependenciesRequestController = null;" in source
|
|
assert "_dependenciesRequestController?.abort();" in source
|
|
assert "const depController = new AbortController();" in source
|
|
assert "setTimeout(() => depController.abort(), 20000)" in source
|
|
assert "signal: depController.signal" in source
|
|
assert "if (!resp.ok) throw new Error(`HTTP ${resp.status}" in source
|
|
assert "} finally {\n clearTimeout(depTimer);" in source
|
|
assert "_dependenciesRequestController === depController" in source
|
|
|
|
|
|
def test_server_color_picker_cleanup_precedes_settings_row_rebuild():
|
|
picker = _read("static/js/cookbook-hwfit.js")
|
|
render = _read("static/js/cookbook.js")
|
|
|
|
assert "const onDocumentClick = () => close();" in picker
|
|
assert "document.removeEventListener('click', onDocumentClick);" in picker
|
|
assert "entry._cleanupColorPicker = () =>" in picker
|
|
assert "body.querySelectorAll('.cookbook-server-entry').forEach(entry =>" in render
|
|
assert "entry._cleanupColorPicker?.();" in render
|
|
|
|
|
|
def test_hwfit_custom_picker_listeners_are_cleaned_before_render():
|
|
picker = _read("static/js/cookbook-hwfit.js")
|
|
render = _read("static/js/cookbook.js")
|
|
|
|
assert "wrap._cleanupUsecasePicker = () =>" in picker
|
|
assert "wrap._cleanupEnginePicker = () =>" in picker
|
|
assert "document.removeEventListener('keydown', onDocumentKeydown);" in picker
|
|
assert "body.querySelectorAll('.hwfit-usecase-wrap').forEach(wrap =>" in render
|
|
assert "body.querySelectorAll('.hwfit-engine-wrap').forEach(wrap =>" in render
|
|
|
|
|
|
def test_hwfit_scan_controls_are_idempotently_bound():
|
|
source = _read("static/js/cookbook-hwfit.js")
|
|
|
|
assert source.count("dataset.hwfitScanBound") >= 5
|
|
assert "if (uc && !uc.dataset.hwfitScanBound)" in source
|
|
assert "if (sort && !sort.dataset.hwfitScanBound)" in source
|
|
assert "if (qpref && !qpref.dataset.hwfitScanBound)" in source
|
|
assert "if (engine && !engine.dataset.hwfitScanBound)" in source
|
|
assert "if (search && !search.dataset.hwfitScanBound)" in source
|
|
|
|
|
|
def test_cookbook_close_cancels_active_scans():
|
|
cookbook = _read("static/js/cookbook.js")
|
|
hwfit = _read("static/js/cookbook-hwfit.js")
|
|
serve = _read("static/js/cookbookServe.js")
|
|
|
|
assert "export function _cancelHwfitRequests()" in hwfit
|
|
assert "export function _cancelCachedModelScan()" in serve
|
|
assert "_cancelHwfitRequests();" in cookbook
|
|
assert "_cancelCachedModelScan();" in cookbook
|
|
|
|
|
|
def test_cookbook_close_cancels_dependency_refresh():
|
|
source = _read("static/js/cookbook.js")
|
|
close_start = source.index("function _doClose()")
|
|
close_end = source.index(" const modal =", close_start)
|
|
close_block = source[close_start:close_end]
|
|
assert "_dependenciesFetchId++;" in close_block
|
|
assert "_dependenciesRequestController?.abort();" in close_block
|
|
assert "_dependenciesRequestController = null;" in close_block
|
|
|
|
|
|
def test_launch_dependency_preflight_preserves_backend_and_model_context():
|
|
source = _read("static/js/cookbook-hwfit.js")
|
|
|
|
assert "params.set('backend', runBackend);" in source
|
|
assert "params.set('model_hint', modelName);" in source
|
|
assert "if (!r.ok) return true; // An unavailable probe must not falsely block launch." in source
|
|
|
|
|
|
def test_dependency_refresh_passes_cached_models_without_family_filtering():
|
|
source = _read("static/js/cookbook.js")
|
|
|
|
assert "Array.from(_cachedModelIds)" in source
|
|
assert ".filter(id => /krea/i.test" not in source
|
|
assert "_pkgParams.set('model_hint', _hint);" in source
|
|
|
|
|
|
def test_dependency_api_does_not_hide_image_capabilities_by_model_name():
|
|
source = _read("routes/shell_routes.py")
|
|
|
|
assert "has_krea_model" not in source
|
|
assert "has_lama_mlx_model" not in source
|
|
assert "has_ddcolor_mlx_model" not in source
|
|
assert 'p.get("name") not in {"krea_diffusers", "transformers"}' not in source
|
|
|
|
|
|
def test_dependency_status_cache_is_not_fragmented_by_unused_model_hint():
|
|
source = _read("routes/shell_routes.py")
|
|
start = source.index("package_cache_key = (")
|
|
end = source.index(")\n cached_status", start)
|
|
assert "model_hint" not in source[start:end]
|
|
|
|
|
|
def test_model_lists_fade_after_complete_rows_are_painted():
|
|
hwfit = _read("static/js/cookbook-hwfit.js")
|
|
cookbook = _read("static/js/cookbook.js")
|
|
style = app_css()
|
|
|
|
assert "cookbook-model-list-fade" in hwfit
|
|
assert "cookbook-model-list-fade" in cookbook
|
|
assert "@keyframes cookbook-model-list-fade-in" in style
|
|
assert "cookbook-hwfit-models-just-loaded" in hwfit
|
|
assert "cookbook-hwfit-models-just-loaded" in style
|
|
assert "prefers-reduced-motion" in style
|
|
|
|
|
|
def test_dependency_panel_has_stable_categories_and_mobile_build_action():
|
|
cookbook = _read("static/js/cookbook.js")
|
|
style = app_css()
|
|
|
|
assert "const _depCategoryOrder = ['System', 'Tools', 'LLM', 'Image'" in cookbook
|
|
assert "const _orderedDepCategories = (byCat)" in cookbook
|
|
assert "String(p.name || '').startsWith('mlx_')" in cookbook
|
|
assert "cookbook-dep-build-deps" in cookbook
|
|
assert ".cookbook-dep-build-deps" in style
|
|
assert "white-space: normal" in style
|
|
assert ".cookbook-dep-row > .cookbook-dep-info" in style
|
|
assert ".cookbook-dep-row > .cookbook-dep-tag" in style
|
|
assert "transform: translateY(2px)" in style
|
|
assert ".cookbook-dep-row > .cookbook-dep-installed-btn" in style
|
|
assert ".cookbook-dep-row > .cookbook-dep-install" in style
|
|
|
|
|
|
def test_direct_download_auto_fold_requires_deliberate_boundary_gesture():
|
|
source = _read("static/js/cookbook.js")
|
|
assert "y > prev + 12" in source
|
|
assert "e.deltaY < -8" in source
|
|
assert "endY - _touchStartY > 24" in source
|
|
|
|
|
|
def test_launch_command_box_uses_accent_focus_glow():
|
|
style = app_css()
|
|
assert ".hwfit-serve-cmd-details[open] .hwfit-serve-cmd" in style
|
|
assert "box-shadow: 0 0 0 1px color-mix(in srgb, var(--accent" in style
|
|
|
|
|
|
def test_server_settings_color_picker_uses_dot_trigger():
|
|
cookbook = _read("static/js/cookbook.js")
|
|
hwfit = _read("static/js/cookbook-hwfit.js")
|
|
style = app_css()
|
|
assert 'aria-label="Change server color (currently ${esc(selectedColorLabel)})"' in cookbook
|
|
assert "btn.setAttribute('aria-label', `Change server color (currently ${label})`)" in hwfit
|
|
assert ".cookbook-server-row .cookbook-srv-color-dot" in style
|
|
assert "width: 12px" in style
|
|
assert "background: transparent" in style
|
|
assert ".cookbook-server-row .cookbook-srv-color-btn:hover" in style
|
|
|
|
|
|
def test_default_server_matches_exclusive_model_directory_selector():
|
|
cookbook = _read("static/js/cookbook.js")
|
|
hwfit = _read("static/js/cookbook-hwfit.js")
|
|
style = app_css()
|
|
assert "const icon = active ? _MODELDIR_CHECK_ON : _MODELDIR_CHECK_OFF;" in cookbook
|
|
assert "_envState.defaultServer = key;" in hwfit
|
|
assert "Toggle off if it's already the default" not in hwfit
|
|
assert ".cookbook-srv-default-icon svg" in style
|
|
|
|
|
|
def test_trending_models_use_headroom_when_filtering_vram():
|
|
source = _read("routes/cookbook_routes.py")
|
|
assert "usable_vram = vram_gb * 0.90" in source
|
|
assert "needed_vram > usable_vram" in source
|
|
|
|
|
|
def test_dependency_deeplink_preserves_the_failed_model_hint():
|
|
cookbook = _read("static/js/cookbook.js")
|
|
diagnosis = _read("static/js/cookbook-diagnosis.js")
|
|
|
|
assert "let _dependenciesModelHint = '';" in cookbook
|
|
assert "_dependenciesModelHint," in cookbook
|
|
assert "dependencyModel: opts.model || ''" in diagnosis
|
|
assert "_dependenciesModelHint = String(opts?.dependencyModel || '').trim();" in cookbook
|
|
|
|
|
|
def test_services_exports_are_lazy_for_cookbook_startup():
|
|
source = _read("services/__init__.py")
|
|
|
|
assert "from importlib import import_module" in source
|
|
assert "_LAZY_EXPORTS" in source
|
|
assert "def __getattr__(name):" in source
|
|
assert "from .search import" not in source
|
|
assert "from .docs import" not in source
|
|
assert "from .research import" not in source
|
|
assert "from .memory import" not in source
|
|
assert "from .shell import" not in source
|
|
|
|
|
|
def test_image_catalog_uses_persistent_stale_cache():
|
|
source = _read("services/hwfit/image_models.py")
|
|
|
|
assert "_IMAGE_COLLECTION_DISK_CACHE" in source
|
|
assert "_IMAGE_COLLECTION_DISK_TTL" in source
|
|
assert "cached_models" in source
|
|
assert "tmp.replace(_IMAGE_COLLECTION_DISK_CACHE)" in source
|
|
assert "Preserve stale results if the network is unavailable" in source
|
|
|
|
|
|
def test_schedule_api_calls_are_bounded():
|
|
source = _read("static/js/cookbookSchedule.js")
|
|
|
|
assert "function fetchWithTimeout(input, init = {}, timeoutMs = 20000)" in source
|
|
assert "return fetch(input, { ...init, signal: controller.signal }).finally" in source
|
|
assert source.count("fetchWithTimeout(") >= 5
|
|
assert "await fetch(\"/api/tasks\"" not in source
|
|
assert "await fetch(\"/api/calendar/calendars\"" not in source
|
|
assert "await fetch(\"/api/calendar/events\"" not in source
|
|
|
|
|
|
def test_diagnosis_quick_commands_have_a_bounded_request():
|
|
source = _read("static/js/cookbook-diagnosis.js")
|
|
|
|
assert "function _diagFetchWithTimeout(input, init = {}, timeoutMs = 75000)" in source
|
|
assert "const timer = setTimeout(() => controller.abort(), timeoutMs);" in source
|
|
assert "await _diagFetchWithTimeout('/api/shell/exec'" in source
|
|
|
|
|
|
def test_serve_scans_have_timeouts_and_do_not_overlap_gpu_polls():
|
|
source = _read("static/js/cookbookServe.js")
|
|
|
|
assert "function _fetchCookbookWithTimeout(input, init = {}, timeoutMs = 20000)" in source
|
|
assert "setTimeout(() => controller.abort(), timeoutMs)" in source
|
|
assert "_fetchCookbookWithTimeout(`/api/model/cached${params}`" in source
|
|
assert "_fetchCookbookWithTimeout('/api/cookbook/gpus'" in source
|
|
assert "let _vramMonitorInFlight = false;" in source
|
|
assert "if (_vramMonitorInFlight) return true;" in source
|
|
assert "_vramMonitorInFlight = false;" in source
|
|
|
|
|
|
def test_cached_model_scans_are_single_flight_per_target():
|
|
source = _read("static/js/cookbookServe.js")
|
|
|
|
assert "async function _fetchCachedModelsImpl(fresh = false, opts = {})" in source
|
|
assert "const _cachedModelsInFlight = new Map();" in source
|
|
assert "const existing = _cachedModelsInFlight.get(key);" in source
|
|
assert "if (existing) return existing;" in source
|
|
assert "pending.then(clearPending, clearPending);" in source
|
|
|
|
|
|
def test_superseded_cached_model_scans_are_cancelled():
|
|
source = _read("static/js/cookbookServe.js")
|
|
|
|
assert "let _cachedModelsRequestController = null;" in source
|
|
assert "_cachedModelsRequestController?.abort();" in source
|
|
assert "const _requestController = new AbortController();" in source
|
|
assert "signal: _requestController.signal" in source
|
|
|
|
|
|
def test_hwfit_network_actions_have_bounded_requests():
|
|
source = _read("static/js/cookbook-hwfit.js")
|
|
|
|
assert "function _fetchHwfitWithTimeout(input, init = {}, timeoutMs = 20000)" in source
|
|
assert "setTimeout(() => controller.abort(), timeoutMs)" in source
|
|
assert "_fetchHwfitWithTimeout(endpoint, { signal: _requestController.signal }, 30000)" in source
|
|
assert "const _cacheFetchToken = _tk;" in source
|
|
assert "_fetchHwfitWithTimeout(`/api/model/cached?${_cacheParams}`" in source
|
|
assert "if (_cacheFetchToken !== _hwfitFetchToken) return;" in source
|
|
assert "_fetchHwfitWithTimeout('/api/model/serve'" in source
|
|
assert "_fetchHwfitWithTimeout('/api/cookbook/test-ssh'" in source
|
|
assert "await fetch(" not in source
|
|
|
|
|
|
def test_serve_gpu_and_context_actions_use_bounded_requests():
|
|
source = _read("static/js/cookbookServe.js")
|
|
|
|
assert "_fetchCookbookWithTimeout(`/api/hwfit/profiles?${params}`, {}, 30000)" in source
|
|
assert "_fetchCookbookWithTimeout(url, { credentials: 'same-origin' }, 10000)" in source
|
|
assert source.count("_fetchCookbookWithTimeout('/api/cookbook/gpus'") >= 3
|
|
assert source.count("_fetchCookbookWithTimeout('/api/cookbook/kill-pid'") >= 3
|
|
assert "await fetch(" not in source
|
|
|
|
|
|
def test_download_control_requests_are_bounded_but_sse_stream_remains_cancellable():
|
|
source = _read("static/js/cookbookDownload.js")
|
|
|
|
assert "function _fetchDownloadControlWithTimeout(input, init = {}, timeoutMs = 20000)" in source
|
|
assert "setTimeout(() => controller.abort(), timeoutMs)" in source
|
|
assert "_fetchDownloadControlWithTimeout('/api/shell/exec'" in source
|
|
assert "_fetchDownloadControlWithTimeout('/api/model/download'" in source
|
|
assert "const res = await fetch('/api/shell/stream'" in source
|
|
assert "signal: controller.signal" in source
|
|
|
|
|
|
def test_main_cookbook_catalog_lookups_surface_http_failures_and_timeout():
|
|
source = _read("static/js/cookbook.js")
|
|
|
|
assert "function _fetchCookbookUiWithTimeout(input, init = {}, timeoutMs = 20000)" in source
|
|
assert "_fetchCookbookUiWithTimeout(`/api/hwfit/system?${qp}`, {}, 20000)" in source
|
|
assert "_fetchCookbookUiWithTimeout(`/api/cookbook/hf-latest?${params}`, {}, 30000)" in source
|
|
assert "_fetchCookbookUiWithTimeout(`/api/cookbook/ollama/library${refresh ? '?refresh=1' : ''}`, {}, 30000)" in source
|
|
assert "if (!res.ok) throw new Error(`HTTP ${res.status}`);" in source
|
|
|
|
|
|
def test_hwfit_superseded_scans_are_cancelled_and_cannot_paint_errors():
|
|
source = _read("static/js/cookbook-hwfit.js")
|
|
|
|
assert "let _hwfitRequestController = null;" in source
|
|
assert "_hwfitRequestController?.abort();" in source
|
|
assert "const _requestController = new AbortController();" in source
|
|
assert "signal: _requestController.signal" in source
|
|
assert source.count("_tk !== _hwfitFetchToken") >= 4
|
|
|
|
|
|
def test_ollama_catalog_lookup_is_single_flight_and_checks_http_status():
|
|
source = _read("static/js/cookbook-hwfit.js")
|
|
|
|
assert "let _ollamaLibInFlight = null;" in source
|
|
assert "if (_ollamaLibInFlight) return _ollamaLibInFlight;" in source
|
|
assert "if (!res.ok) throw new Error(`HTTP ${res.status}`);" in source
|
|
assert "pending.then(clearPending, clearPending);" in source
|
|
|
|
|
|
def test_bulk_task_clear_uses_shared_card_disposer():
|
|
source = _read("static/js/cookbookRunning.js")
|
|
|
|
assert "toRemove.forEach(t => {\n const el = document.querySelector(`.cookbook-task[data-task-id=\"${t.sessionId}\"]`);\n if (el) {\n _disposeTaskCard(el);" in source
|
|
assert "_disposeTaskCard(el);\n el.remove();" in source
|
|
|
|
|
|
def test_task_card_disposer_cancels_mobile_long_press():
|
|
source = _read("static/js/cookbookRunning.js")
|
|
|
|
assert "if (el._longPressTimer)" in source
|
|
assert "el._longPressTimer = setTimeout" in source
|
|
assert "el._longPressTimer = null;" in source
|
|
|
|
|
|
def test_cached_model_rerender_cancels_mobile_long_press():
|
|
source = _read("static/js/cookbookServe.js")
|
|
|
|
assert "list.querySelectorAll('.memory-item').forEach(item =>" in source
|
|
assert "item._longPressTimer" in source
|
|
assert "clearTimeout(item._longPressTimer);" in source
|
|
|
|
|
|
def test_main_cookbook_control_actions_use_bounded_requests():
|
|
source = _read("static/js/cookbook.js")
|
|
|
|
assert source.count("_fetchCookbookUiWithTimeout('/api/model/serve'") >= 3
|
|
assert "_fetchCookbookUiWithTimeout('/api/cookbook/install-system-deps'" in source
|
|
assert "_fetchCookbookUiWithTimeout('/api/cookbook/rebuild-engine'" in source
|
|
assert "_fetchCookbookUiWithTimeout(`/api/cookbook/hf-gguf-files?repo_id=" in source
|
|
|
|
|
|
def test_cookbook_opens_from_cached_state_before_background_sync():
|
|
source = _read("static/js/cookbook.js")
|
|
|
|
assert "const _stateSync = _syncFromServer();" in source
|
|
assert source.index("_renderCookbookShell();") < source.index("const _stateSync = _syncFromServer();")
|
|
assert "modal.classList.remove('hidden');" in source
|
|
assert "_stateSync.then((synced) =>" in source
|
|
assert "never replace a form while the" in source
|
|
assert "let _cookbookOpenGeneration = 0;" in source
|
|
assert "_openGeneration !== _cookbookOpenGeneration" in source
|
|
assert "if (activeTab === 'Running' || activeTab === 'Serve') return;" in source
|
|
assert "const _initialStateSignature = _cookbookStateSignature();" in source
|
|
assert "if (_cookbookStateSignature() === _initialStateSignature) return;" in source
|
|
|
|
|
|
def test_advanced_scan_dismissal_is_single_document_binding():
|
|
source = _read("static/js/cookbook.js")
|
|
|
|
assert "document._cookbookAdvancedDismissWired" in source
|
|
assert "const currentPanel = document.getElementById('hwfit-advanced-panel');" in source
|
|
assert "document.addEventListener('click', () => setAdvancedOpen(false));" not in source
|
|
assert "document.addEventListener('keydown', (ev) => {\n if (ev.key === 'Escape') setAdvancedOpen(false);" not in source
|
|
|
|
|
|
def test_serve_panel_removes_global_handlers_when_collapsed():
|
|
source = _read("static/js/cookbookServe.js")
|
|
cookbook_source = _read("static/js/cookbook.js")
|
|
|
|
assert "let _cleanupBackendDismiss = () => {};" in source
|
|
assert "panel._cleanupServePanel = () => {" in source
|
|
assert "_cleanupBackendDismiss?.();" in source
|
|
assert "document.removeEventListener('keydown', _onEscClose, true);" in source
|
|
assert "existingPanel?._cleanupServePanel?.();" in source
|
|
assert "openPanel?._cleanupServePanel?.();" in source
|
|
assert "clearInterval(_vramTimer);" in source
|
|
assert "expandedPanel?._cleanupServePanel?.();" in cookbook_source
|
|
|
|
|
|
def test_gpu_probe_popup_removes_deferred_outside_listener_on_close():
|
|
source = _read("static/js/cookbookServe.js")
|
|
|
|
assert "panel._gpuProbe.outsideAttachTimer" in source
|
|
assert "panel._gpuProbe.outsideHandler" in source
|
|
assert "document.removeEventListener('mousedown', panel._gpuProbe.outsideHandler, true);" in source
|
|
assert "_closeProbePopup();" in source
|
|
|
|
|
|
def test_dependency_install_payload_keeps_env_path_for_refresh():
|
|
source = _read("static/js/cookbook.js")
|
|
|
|
assert "env_path: targetEnvPath || ''" in source
|
|
|
|
|
|
def test_local_dependency_probe_refreshes_user_site_visibility():
|
|
source = _read("routes/shell_routes.py")
|
|
|
|
assert "importlib.invalidate_caches()" in source
|
|
assert "user_site = site.getusersitepackages()" in source
|
|
# addsitedir (not a bare sys.path.append) so user-site `.pth` hooks are
|
|
# replayed when a package is installed into an already-running process —
|
|
# otherwise setuptools' distutils shim never activates and basicsr-based
|
|
# deps (realesrgan) probe as not-installed until a restart. See #4810.
|
|
assert "if user_site and os.path.isdir(user_site):" in source
|
|
assert "site.addsitedir(user_site)" in source
|
|
|
|
|
|
def test_llama_runner_path_preserves_standard_user_bin_order():
|
|
"""The runner PATH must preserve standard user $HOME/bin precedence while
|
|
relying on ownership-aware reconciliation to retire Odysseus shims when
|
|
native builds exist."""
|
|
source = _read("routes/cookbook_routes.py")
|
|
|
|
assert (
|
|
'export PATH="$HOME/.local/bin:$HOME/bin:$HOME/llama.cpp/build/bin:/opt/homebrew/bin:/usr/local/bin:$PATH"'
|
|
in source
|
|
)
|
|
|
|
|
|
def _run_shell(tmp_path, lines, cwd=None, path=None, extra_env=None):
|
|
from core.platform_compat import find_bash, git_bash_path
|
|
bash = find_bash() or "bash"
|
|
env = dict(os.environ, HOME=git_bash_path(tmp_path))
|
|
if path is not None:
|
|
env["PATH"] = path
|
|
if extra_env:
|
|
env.update(extra_env)
|
|
return subprocess.run(
|
|
[bash, "-c", "\n".join(lines)],
|
|
cwd=str(cwd) if cwd else None,
|
|
env=env,
|
|
capture_output=True,
|
|
text=True,
|
|
)
|
|
|
|
|
|
def _write_odysseus_shim(path: Path) -> None:
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
path.write_text(
|
|
f"#!/usr/bin/env bash\n{ODYSSEUS_LLAMA_SHIM_MARKER}\nexec python3 -m llama_cpp.server \"$@\"\n",
|
|
encoding="utf-8",
|
|
)
|
|
path.chmod(0o755)
|
|
|
|
|
|
def _write_mock_native(path: Path, succeeds: bool = True) -> None:
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
if succeeds:
|
|
content = '#!/usr/bin/env bash\nif [ "$1" = "--version" ]; then echo "version: 0.1.0-dev"; exit 0; fi\necho "RUN_NATIVE: $@"\nexit 0\n'
|
|
else:
|
|
content = '#!/usr/bin/env bash\necho "error: missing libllama.so" >&2\nexit 127\n'
|
|
path.write_text(content, encoding="utf-8")
|
|
path.chmod(0o755)
|
|
|
|
|
|
def _write_mock_python3(path: Path, succeeds: bool = True) -> None:
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
path.write_text(f"#!/usr/bin/env bash\nexit {0 if succeeds else 1}\n", encoding="utf-8")
|
|
path.chmod(0o755)
|
|
|
|
|
|
def test_odysseus_create_llama_shim_never_overwrites_user_regular_file(tmp_path):
|
|
"""Creation boundary: never overwrite a non-executable user-owned regular file."""
|
|
user_file = tmp_path / "bin/llama-server"
|
|
user_file.parent.mkdir(parents=True, exist_ok=True)
|
|
original_content = "user configuration or binary data without marker"
|
|
user_file.write_text(original_content, encoding="utf-8")
|
|
|
|
lines = []
|
|
_append_llama_server_shim_definition_lines(lines)
|
|
lines.append('_odysseus_create_llama_shim')
|
|
|
|
res = _run_shell(tmp_path, lines)
|
|
assert res.returncode != 0, "Creation should return non-zero when target is a user file"
|
|
assert user_file.read_text(encoding="utf-8") == original_content, "User file must remain byte-for-byte unchanged"
|
|
|
|
|
|
def test_odysseus_create_llama_shim_never_overwrites_user_symlink(tmp_path):
|
|
"""Creation boundary: never follow or overwrite a user-owned symlink."""
|
|
bin_dir = tmp_path / "bin"
|
|
bin_dir.mkdir(parents=True, exist_ok=True)
|
|
target_file = tmp_path / "user_target.txt"
|
|
target_file.write_text("precious user target content", encoding="utf-8")
|
|
user_symlink = bin_dir / "llama-server"
|
|
user_symlink.symlink_to(target_file)
|
|
|
|
lines = []
|
|
_append_llama_server_shim_definition_lines(lines)
|
|
lines.append('_odysseus_create_llama_shim')
|
|
|
|
res = _run_shell(tmp_path, lines)
|
|
assert res.returncode != 0, "Creation should return non-zero when target is a user symlink"
|
|
assert user_symlink.is_symlink(), "Symlink must remain intact"
|
|
assert target_file.read_text(encoding="utf-8") == "precious user target content", "Target file must not be modified"
|
|
|
|
|
|
def test_odysseus_create_llama_shim_never_overwrites_dangling_symlink(tmp_path):
|
|
"""Creation boundary: never overwrite a dangling user-owned symlink."""
|
|
bin_dir = tmp_path / "bin"
|
|
bin_dir.mkdir(parents=True, exist_ok=True)
|
|
dangling_symlink = bin_dir / "llama-server"
|
|
dangling_symlink.symlink_to(tmp_path / "nonexistent_target")
|
|
|
|
lines = []
|
|
_append_llama_server_shim_definition_lines(lines)
|
|
lines.append('_odysseus_create_llama_shim')
|
|
|
|
res = _run_shell(tmp_path, lines)
|
|
assert res.returncode != 0, "Creation should return non-zero when target is a dangling symlink"
|
|
assert dangling_symlink.is_symlink(), "Dangling symlink must remain intact"
|
|
|
|
|
|
def test_odysseus_create_llama_shim_safely_replaces_existing_odysseus_shim(tmp_path):
|
|
"""Creation boundary: safely replace an existing Odysseus-owned compatibility shim."""
|
|
shim_file = tmp_path / "bin/llama-server"
|
|
shim_file.parent.mkdir(parents=True, exist_ok=True)
|
|
shim_file.write_text(f"#!/bin/bash\n{ODYSSEUS_LLAMA_SHIM_MARKER}\n# old shim body\n", encoding="utf-8")
|
|
|
|
lines = []
|
|
_append_llama_server_shim_definition_lines(lines)
|
|
lines.append('_odysseus_create_llama_shim')
|
|
|
|
res = _run_shell(tmp_path, lines)
|
|
assert res.returncode == 0
|
|
new_content = shim_file.read_text(encoding="utf-8")
|
|
assert ODYSSEUS_LLAMA_SHIM_MARKER in new_content
|
|
assert "exec python3 -m llama_cpp.server" in new_content
|
|
|
|
|
|
def test_odysseus_create_llama_shim_secure_temp_prevents_symlink_attack(tmp_path):
|
|
"""Creation boundary: secure mktemp prevents predictable $$ temp symlink attacks.
|
|
|
|
Given:
|
|
- A victim file at ~/victim containing DO_NOT_TOUCH
|
|
- A pre-created symlink at ~/bin/.llama-server.odysseus.tmp.$$ pointing to ~/victim
|
|
- _odysseus_create_llama_shim executed within that exact same bash PID ($$)
|
|
|
|
Prove:
|
|
- ~/victim remains unmodified
|
|
- Pre-existing crafted symlink is NOT followed or overwritten
|
|
- Legitimate shim is successfully created at ~/bin/llama-server via secure temp path
|
|
"""
|
|
lines = [
|
|
'victim="$HOME/victim"',
|
|
'printf "DO_NOT_TOUCH\\n" > "$victim"',
|
|
'mkdir -p "$HOME/bin"',
|
|
'old_tmp="$HOME/bin/.llama-server.odysseus.tmp.$$";',
|
|
'ln -s "$victim" "$old_tmp"',
|
|
]
|
|
_append_llama_server_shim_definition_lines(lines)
|
|
lines.append('_odysseus_create_llama_shim')
|
|
lines.append('res=$?')
|
|
lines.append('echo "CREATION_RES=$res"')
|
|
|
|
res = _run_shell(tmp_path, lines)
|
|
assert res.returncode == 0
|
|
assert "CREATION_RES=0" in res.stdout
|
|
|
|
victim_file = tmp_path / "victim"
|
|
assert victim_file.exists()
|
|
assert victim_file.read_text(encoding="utf-8") == "DO_NOT_TOUCH\n", "Victim file must remain untouched"
|
|
|
|
target_shim = tmp_path / "bin/llama-server"
|
|
assert target_shim.exists()
|
|
assert ODYSSEUS_LLAMA_SHIM_MARKER in target_shim.read_text(encoding="utf-8")
|
|
assert target_shim.stat().st_mode & 0o111 != 0, "Shim must be executable"
|
|
|
|
|
|
def test_stale_odysseus_shim_removed_when_python_server_unusable(tmp_path):
|
|
"""Scenario 1: Stale Odysseus shim + missing Python server -> owned shim removed."""
|
|
shim_file = tmp_path / "bin/llama-server"
|
|
_write_odysseus_shim(shim_file)
|
|
|
|
lines = []
|
|
_append_llama_server_shim_reconciliation_lines(lines)
|
|
|
|
res = _run_shell(tmp_path, lines)
|
|
assert res.returncode == 0
|
|
assert not shim_file.exists(), "Stale Odysseus shim must be removed when python server is unavailable"
|
|
|
|
|
|
def test_healthy_odysseus_shim_retained_when_no_native_server(tmp_path):
|
|
"""Scenario 2: Healthy Odysseus shim + no native server -> shim preserved."""
|
|
shim_file = tmp_path / "bin/llama-server"
|
|
_write_odysseus_shim(shim_file)
|
|
mock_py_dir = tmp_path / "mock_bin"
|
|
_write_mock_python3(mock_py_dir / "python3", succeeds=True)
|
|
|
|
lines = []
|
|
_append_llama_server_shim_reconciliation_lines(lines)
|
|
|
|
res = _run_shell(tmp_path, lines, path=f"{git_bash_path(mock_py_dir)}:{os.environ.get('PATH', '')}")
|
|
assert res.returncode == 0
|
|
assert shim_file.exists(), "Healthy Odysseus shim must be preserved when no native server is present"
|
|
|
|
|
|
def test_reconciliation_does_not_retire_healthy_shim_for_broken_native_binary(tmp_path):
|
|
"""Reconciliation health check: a broken native candidate executable must NOT retire
|
|
a healthy Odysseus Python shim."""
|
|
shim_file = tmp_path / "bin/llama-server"
|
|
_write_odysseus_shim(shim_file)
|
|
_write_mock_native(tmp_path / "llama.cpp/build/bin/llama-server", succeeds=False)
|
|
mock_py_dir = tmp_path / "mock_bin"
|
|
_write_mock_python3(mock_py_dir / "python3", succeeds=True)
|
|
|
|
lines = [f'export PATH="$HOME/llama.cpp/build/bin:{git_bash_path(mock_py_dir)}:$PATH"']
|
|
_append_llama_server_shim_reconciliation_lines(lines)
|
|
|
|
res = _run_shell(tmp_path, lines)
|
|
assert res.returncode == 0
|
|
assert shim_file.exists(), "Healthy Odysseus shim must NOT be retired when native binary is broken"
|
|
|
|
|
|
def test_odysseus_shim_retired_when_native_server_healthy(tmp_path):
|
|
"""Scenario 3: Odysseus shim + healthy native server available -> native server wins."""
|
|
shim_file = tmp_path / "bin/llama-server"
|
|
_write_odysseus_shim(shim_file)
|
|
_write_mock_native(tmp_path / "llama.cpp/build/bin/llama-server", succeeds=True)
|
|
|
|
lines = ['export PATH="$HOME/bin:$HOME/llama.cpp/build/bin:$PATH"']
|
|
_append_llama_server_shim_reconciliation_lines(lines)
|
|
|
|
res = _run_shell(tmp_path, lines)
|
|
assert res.returncode == 0
|
|
assert not shim_file.exists(), "Odysseus shim must be retired when healthy native server is available"
|
|
|
|
|
|
def test_user_owned_bin_llama_server_never_touched(tmp_path):
|
|
"""Scenario 4: Arbitrary user ~/bin/llama-server -> untouched and not deprioritized."""
|
|
user_bin = tmp_path / "bin/llama-server"
|
|
user_bin.parent.mkdir(parents=True, exist_ok=True)
|
|
user_bin.write_text("#!/bin/bash\n# Custom user build script\nexec /opt/custom/llama-server\n", encoding="utf-8")
|
|
user_bin.chmod(0o755)
|
|
|
|
_write_mock_native(tmp_path / "llama.cpp/build/bin/llama-server", succeeds=True)
|
|
|
|
lines = ['export PATH="$HOME/bin:$HOME/llama.cpp/build/bin:$PATH"']
|
|
_append_llama_server_shim_reconciliation_lines(lines)
|
|
|
|
res = _run_shell(tmp_path, lines)
|
|
assert res.returncode == 0
|
|
assert user_bin.exists(), "User-owned ~/bin/llama-server must never be deleted"
|
|
assert "Custom user build script" in user_bin.read_text(encoding="utf-8")
|
|
|
|
|
|
def test_reconciliation_ignores_native_binary_outside_effective_path(tmp_path):
|
|
"""Native candidate outside effective PATH must NOT be considered."""
|
|
shim_file = tmp_path / "bin/llama-server"
|
|
_write_odysseus_shim(shim_file)
|
|
# Native binary placed in /usr_custom/bin which is NOT in PATH
|
|
_write_mock_native(tmp_path / "usr_custom/bin/llama-server", succeeds=True)
|
|
mock_py_dir = tmp_path / "mock_bin"
|
|
_write_mock_python3(mock_py_dir / "python3", succeeds=True)
|
|
|
|
lines = []
|
|
_append_llama_server_shim_reconciliation_lines(lines)
|
|
|
|
# PATH only contains ~/bin and mock_py_dir — usr_custom is omitted
|
|
path = f"{git_bash_path(tmp_path / 'bin')}:{git_bash_path(mock_py_dir)}"
|
|
res = _run_shell(tmp_path, lines, path=path)
|
|
assert res.returncode == 0
|
|
assert shim_file.exists(), "Shim must NOT be retired by native binary outside effective PATH"
|
|
|
|
|
|
def test_reconciliation_skips_home_bin_with_or_without_trailing_slash(tmp_path):
|
|
"""Reconciliation must exclude $HOME/bin and $HOME/bin/ from native candidate discovery."""
|
|
shim_file = tmp_path / "bin/llama-server"
|
|
_write_odysseus_shim(shim_file)
|
|
mock_py_dir = tmp_path / "mock_bin"
|
|
_write_mock_python3(mock_py_dir / "python3", succeeds=True)
|
|
|
|
lines = []
|
|
_append_llama_server_shim_reconciliation_lines(lines)
|
|
|
|
# PATH has ~/bin/ with trailing slash
|
|
path = f"{git_bash_path(tmp_path / 'bin')}/:{git_bash_path(mock_py_dir)}"
|
|
res = _run_shell(tmp_path, lines, path=path)
|
|
assert res.returncode == 0
|
|
assert shim_file.exists(), "Shim must NOT rediscover itself when PATH has trailing slash in $HOME/bin/"
|
|
|
|
|
|
def test_reconciliation_does_not_discover_cwd_executable_when_path_omits_dot(tmp_path):
|
|
"""Reconciliation must NOT synthesize an empty/trailing PATH element that searches cwd.
|
|
|
|
Given:
|
|
- Current working directory contains an executable `llama-server`
|
|
- Healthy Odysseus Python shim in ~/bin/llama-server
|
|
- PATH does NOT contain '.' or cwd
|
|
- No other healthy native binary on PATH
|
|
|
|
Prove:
|
|
- Reconciliation does not discover ./llama-server
|
|
- The healthy Odysseus shim in ~/bin/llama-server is preserved
|
|
"""
|
|
shim_file = tmp_path / "bin/llama-server"
|
|
_write_odysseus_shim(shim_file)
|
|
mock_py_dir = tmp_path / "mock_bin"
|
|
_write_mock_python3(mock_py_dir / "python3", succeeds=True)
|
|
|
|
cwd_dir = tmp_path / "workdir"
|
|
_write_mock_native(cwd_dir / "llama-server", succeeds=True)
|
|
|
|
lines = []
|
|
_append_llama_server_shim_reconciliation_lines(lines)
|
|
|
|
path = f"{git_bash_path(tmp_path / 'bin')}:{git_bash_path(mock_py_dir)}:/usr/bin:/bin"
|
|
res = _run_shell(tmp_path, lines, cwd=cwd_dir, path=path)
|
|
assert res.returncode == 0
|
|
assert shim_file.exists(), "Healthy Odysseus shim must NOT be retired by finding ./llama-server in cwd"
|
|
|
|
|
|
def test_reconciliation_discovers_healthy_native_on_explicit_other_path_entry(tmp_path):
|
|
"""Reconciliation must discover healthy native binaries placed on explicit PATH entries."""
|
|
shim_file = tmp_path / "bin/llama-server"
|
|
_write_odysseus_shim(shim_file)
|
|
custom_opt_bin = tmp_path / "custom_opt/bin"
|
|
_write_mock_native(custom_opt_bin / "llama-server", succeeds=True)
|
|
|
|
lines = []
|
|
_append_llama_server_shim_reconciliation_lines(lines)
|
|
|
|
path = f"{git_bash_path(tmp_path / 'bin')}:{git_bash_path(custom_opt_bin)}:/usr/bin:/bin"
|
|
res = _run_shell(tmp_path, lines, path=path)
|
|
assert res.returncode == 0
|
|
assert not shim_file.exists(), "Odysseus shim must be retired when healthy native server is on explicit PATH entry"
|
|
|
|
|
|
def test_reconciliation_safely_iterates_path_with_glob_metacharacters(tmp_path):
|
|
"""Reconciliation must not perform pathname expansion / globbing on PATH components.
|
|
|
|
Given:
|
|
- A directory path containing shell glob characters: ~/custom[dir]/bin
|
|
- A native binary ~/custom[dir]/bin/llama-server
|
|
- A working directory containing matching glob entries
|
|
- An existing Odysseus shim in ~/bin/llama-server
|
|
|
|
Prove:
|
|
- Reconciliation correctly parses the literal path without expanding [dir]
|
|
- Discovers the healthy native server and retires the Odysseus shim
|
|
"""
|
|
shim_file = tmp_path / "bin/llama-server"
|
|
_write_odysseus_shim(shim_file)
|
|
|
|
glob_dir = tmp_path / "custom[dir]/bin"
|
|
_write_mock_native(glob_dir / "llama-server", succeeds=True)
|
|
|
|
cwd_dir = tmp_path / "cwd"
|
|
cwd_dir.mkdir(parents=True, exist_ok=True)
|
|
(cwd_dir / "customd").mkdir(parents=True, exist_ok=True)
|
|
(cwd_dir / "customi").mkdir(parents=True, exist_ok=True)
|
|
|
|
lines = []
|
|
_append_llama_server_shim_reconciliation_lines(lines)
|
|
|
|
path = f"{git_bash_path(tmp_path / 'bin')}:{git_bash_path(glob_dir)}:/usr/bin:/bin"
|
|
res = _run_shell(tmp_path, lines, cwd=cwd_dir, path=path)
|
|
assert res.returncode == 0
|
|
assert not shim_file.exists(), "Reconciliation must discover literal bracketed PATH without globbing"
|
|
|
|
|
|
def test_fallback_install_success_creates_usable_launcher(tmp_path):
|
|
"""Scenario 5: No native + no Python server -> fallback install succeeds
|
|
-> usable compatibility launcher exists and resolves command -v llama-server."""
|
|
mock_py_dir = tmp_path / "mock_bin"
|
|
_write_mock_python3(mock_py_dir / "python3", succeeds=True)
|
|
|
|
lines = [f'export PATH="$HOME/bin:{git_bash_path(mock_py_dir)}:$PATH"']
|
|
_append_llama_server_shim_definition_lines(lines)
|
|
_append_llama_server_finalization_lines(lines)
|
|
lines.append('command -v llama-server')
|
|
|
|
res = _run_shell(tmp_path, lines)
|
|
assert res.returncode == 0
|
|
created_shim = tmp_path / "bin/llama-server"
|
|
assert created_shim.exists()
|
|
assert ODYSSEUS_LLAMA_SHIM_MARKER in created_shim.read_text(encoding="utf-8")
|
|
assert str(tmp_path / "bin/llama-server") in res.stdout
|
|
|
|
|
|
def test_failed_fallback_sets_preflight_exit_127(tmp_path):
|
|
"""Scenario 6: No native + failed fallback installation -> ODYSSEUS_PREFLIGHT_EXIT=127."""
|
|
lines = [
|
|
'ODYSSEUS_PREFLIGHT_EXIT=""',
|
|
'export PATH="$HOME/bin:$PATH"',
|
|
]
|
|
_append_llama_server_shim_definition_lines(lines)
|
|
_append_llama_server_finalization_lines(lines)
|
|
lines.append('echo "EXIT=$ODYSSEUS_PREFLIGHT_EXIT"')
|
|
|
|
res = _run_shell(tmp_path, lines)
|
|
assert res.returncode == 0
|
|
assert "EXIT=127" in res.stdout
|
|
|
|
|
|
def test_python_server_readiness_requires_llama_cpp_server_module():
|
|
"""Scenario 7 & 8: Python server readiness requires `import llama_cpp.server`,
|
|
while GPU offload capability checks still use base `import llama_cpp`."""
|
|
routes_source = _read("routes/cookbook_routes.py")
|
|
helpers_source = _read("routes/cookbook_helpers.py")
|
|
|
|
# Windows fallback readiness check requires .server
|
|
assert 'try { python -c "import llama_cpp.server" 2>$null } catch {}' in routes_source
|
|
# Termux fallback readiness check requires .server
|
|
assert 'if ! python3 -c "import llama_cpp.server" 2>/dev/null; then' in routes_source
|
|
# Build-failure fallback pip check requires .server
|
|
assert 'if [ -z "$_odysseus_llama_bin" ] && ! python3 -c "import llama_cpp.server" 2>/dev/null; then' in routes_source
|
|
# Shim reconciliation and post-install finalization require .server
|
|
assert 'elif python3 -c "import llama_cpp.server" 2>/dev/null; then' in helpers_source
|
|
assert 'if [ -z "$_odysseus_llama_bin" ] && python3 -c "import llama_cpp.server" 2>/dev/null; then' in helpers_source
|
|
|
|
# GPU offload support checks still intentionally inspect base llama_cpp
|
|
assert 'llama_cpp.llama_supports_gpu_offload()' in routes_source
|
|
|
|
|
|
def test_darwin_native_build_does_not_force_write_bin_symlink():
|
|
"""Darwin source build must not overwrite ~/bin/llama-server with a forced symlink."""
|
|
source = _read("routes/cookbook_routes.py")
|
|
|
|
assert "&& ln -sf ~/llama.cpp/build/bin/llama-server ~/bin/llama-server" not in source
|
|
assert 'cmake --build build -j"$NPROC" --target llama-server' in source
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_generated_runner_preflight_retires_stale_shim_before_backend_selection(monkeypatch, tmp_path):
|
|
"""Integration regression: The actual generated Cookbook runner must execute
|
|
ownership reconciliation BEFORE evaluating the backend selection (`if Termux ... elif ! command -v llama-server`).
|
|
|
|
Given:
|
|
- Executable stale Odysseus shim in ~/bin/llama-server (with canonical marker)
|
|
- Healthy native llama-server in ~/llama.cpp/build/bin/llama-server
|
|
- ~/bin before ~/llama.cpp/build/bin on PATH
|
|
|
|
Prove:
|
|
1. Generated runner contains reconciliation shell lines strictly before the backend branching
|
|
2. Executing the generated runner script retires the stale ~/bin/llama-server shim
|
|
3. Resolves to the healthy native binary without attempting source build or pip fallback.
|
|
"""
|
|
from unittest.mock import AsyncMock, MagicMock
|
|
from routes.cookbook_helpers import ServeRequest
|
|
import routes.cookbook_routes as cookbook_routes
|
|
from starlette.requests import Request
|
|
|
|
fake_home = tmp_path / "fake_home"
|
|
stale_shim = fake_home / "bin/llama-server"
|
|
_write_odysseus_shim(stale_shim)
|
|
native_bin = fake_home / "llama.cpp/build/bin/llama-server"
|
|
_write_mock_native(native_bin, succeeds=True)
|
|
|
|
# Mock environment to generate the real runner file with isolated DB
|
|
tmux_log_dir = tmp_path / "tmux_logs"
|
|
tmux_log_dir.mkdir(parents=True)
|
|
monkeypatch.setattr(cookbook_routes, "TMUX_LOG_DIR", tmux_log_dir)
|
|
monkeypatch.setattr(cookbook_routes, "require_admin", lambda request: None)
|
|
monkeypatch.setattr(cookbook_routes, "_binary_available", AsyncMock(return_value=True))
|
|
monkeypatch.setattr(cookbook_routes, "load_stored_hf_token", lambda **kwargs: "")
|
|
monkeypatch.setattr("core.database.SessionLocal", MagicMock())
|
|
|
|
class _Proc:
|
|
returncode = 0
|
|
stderr = None
|
|
async def wait(self):
|
|
return 0
|
|
monkeypatch.setattr(cookbook_routes.asyncio, "create_subprocess_shell", AsyncMock(return_value=_Proc()))
|
|
|
|
router = cookbook_routes.setup_cookbook_routes()
|
|
endpoint = None
|
|
for route in router.routes:
|
|
if route.path == "/api/model/serve" and "POST" in route.methods:
|
|
endpoint = route.endpoint
|
|
break
|
|
assert endpoint is not None
|
|
|
|
from types import SimpleNamespace
|
|
http_req = Request({
|
|
"type": "http",
|
|
"method": "POST",
|
|
"path": "/api/model/serve",
|
|
"headers": [],
|
|
"app": SimpleNamespace(state=SimpleNamespace(auth_manager=SimpleNamespace(
|
|
is_configured=True, is_admin=lambda user: user == "admin"))),
|
|
})
|
|
http_req.state.current_user = "admin"
|
|
http_req.state.local_model_authority = True
|
|
|
|
req = ServeRequest(
|
|
repo_id="test/repo",
|
|
cmd="llama-server -m /dummy/model.gguf --port 8085",
|
|
remote_host=None,
|
|
)
|
|
|
|
resp = await endpoint(http_req, req)
|
|
assert resp["ok"] is True
|
|
session_id = resp["session_id"]
|
|
runner_file = tmux_log_dir / f"{session_id}_run.sh"
|
|
assert runner_file.exists()
|
|
runner_script = runner_file.read_text(encoding="utf-8")
|
|
|
|
# Assert structural ordering in the generated script:
|
|
# Reconciliation must appear strictly BEFORE the Termux/backend check
|
|
recon_idx = runner_script.find("Native llama-server detected — retiring Odysseus compatibility shim in ~/bin")
|
|
termux_idx = runner_script.find("if [ -d /data/data/com.termux ]; then")
|
|
backend_idx = runner_script.find('elif [ -z "$_odysseus_llama_bin" ]; then')
|
|
assert recon_idx != -1, "Reconciliation block missing from generated runner"
|
|
assert termux_idx != -1, "Termux check missing from generated runner"
|
|
assert backend_idx != -1, "Backend selection missing from generated runner"
|
|
assert recon_idx < termux_idx < backend_idx, "Reconciliation must execute strictly before backend selection"
|
|
|
|
# Execute the generated runner preflight in a real subshell
|
|
res = _run_shell(fake_home, [str(runner_file)], path=f"{git_bash_path(fake_home / 'bin')}:{git_bash_path(fake_home / 'llama.cpp/build/bin')}:/usr/bin:/bin")
|
|
assert res.returncode == 0
|
|
assert not stale_shim.exists(), "Stale ~/bin/llama-server must have been retired by the generated preflight"
|
|
assert "RUN_NATIVE: -m /dummy/model.gguf --port 8085" in res.stdout
|
|
assert "Native llama-server not found — building from source" not in res.stdout
|
|
|
|
|
|
def test_broken_first_native_candidate_healthy_second_candidate_executes_healthy(tmp_path):
|
|
"""Regression finding P2: When PATH contains an earlier broken candidate followed by a
|
|
healthy candidate, reconciliation and launch must select and execute the healthy candidate."""
|
|
from core.platform_compat import git_bash_path
|
|
broken_dir = tmp_path / "broken_bin"
|
|
_write_mock_native(broken_dir / "llama-server", succeeds=False)
|
|
|
|
healthy_dir = tmp_path / "healthy_bin"
|
|
_write_mock_native(healthy_dir / "llama-server", succeeds=True)
|
|
|
|
shim_file = tmp_path / "bin/llama-server"
|
|
_write_odysseus_shim(shim_file)
|
|
|
|
lines = [
|
|
f'export PATH="$HOME/bin:{git_bash_path(broken_dir)}:{git_bash_path(healthy_dir)}:/usr/bin:/bin"',
|
|
]
|
|
_append_llama_server_shim_reconciliation_lines(lines)
|
|
lines.append('echo "RESOLVED=$_odysseus_llama_bin"')
|
|
lines.append('command -v llama-server')
|
|
lines.append('llama-server -m /dummy/model.gguf --port 8080')
|
|
|
|
res = _run_shell(tmp_path, lines)
|
|
assert res.returncode == 0
|
|
assert not shim_file.exists(), "Stale Odysseus shim must be retired"
|
|
assert f"RESOLVED={git_bash_path(healthy_dir / 'llama-server')}" in res.stdout
|
|
assert str(healthy_dir / "llama-server") in res.stdout
|
|
assert "RUN_NATIVE: -m /dummy/model.gguf --port 8080" in res.stdout
|
|
assert "error: missing libllama.so" not in res.stdout
|
|
|
|
|
|
def test_paths_with_spaces_broken_first_healthy_second_launch(tmp_path):
|
|
"""Regression: Paths containing spaces must be safely resolved, prioritized and launched."""
|
|
from core.platform_compat import git_bash_path
|
|
broken_dir = tmp_path / "broken path with spaces/bin"
|
|
_write_mock_native(broken_dir / "llama-server", succeeds=False)
|
|
|
|
healthy_dir = tmp_path / "healthy path with spaces/bin"
|
|
_write_mock_native(healthy_dir / "llama-server", succeeds=True)
|
|
|
|
shim_file = tmp_path / "bin/llama-server"
|
|
_write_odysseus_shim(shim_file)
|
|
|
|
model_dir = tmp_path / "models with spaces"
|
|
model_dir.mkdir(parents=True, exist_ok=True)
|
|
model_file = model_dir / "my model.gguf"
|
|
model_file.write_text("dummy", encoding="utf-8")
|
|
|
|
lines = [
|
|
f'export PATH="$HOME/bin:{git_bash_path(broken_dir)}:{git_bash_path(healthy_dir)}:/usr/bin:/bin"',
|
|
]
|
|
_append_llama_server_shim_reconciliation_lines(lines)
|
|
lines.append(f'llama-server -m "{git_bash_path(model_file)}" --port 8080')
|
|
|
|
res = _run_shell(tmp_path, lines)
|
|
assert res.returncode == 0
|
|
assert not shim_file.exists(), "Stale shim must be retired"
|
|
assert f"RUN_NATIVE: -m {git_bash_path(model_file)} --port 8080" in res.stdout
|
|
assert "error: missing libllama.so" not in res.stdout
|
|
|
|
|
|
def test_command_hash_invalidation_switches_from_cached_broken_to_healthy(tmp_path):
|
|
"""Regression: Command cache invalidation (`hash -r`) must prevent bash from reusing a
|
|
previously cached lookup to an earlier broken executable."""
|
|
from core.platform_compat import git_bash_path
|
|
broken_dir = tmp_path / "broken_bin"
|
|
_write_mock_native(broken_dir / "llama-server", succeeds=False)
|
|
|
|
healthy_dir = tmp_path / "healthy_bin"
|
|
_write_mock_native(healthy_dir / "llama-server", succeeds=True)
|
|
|
|
lines = [
|
|
# Populate bash hash cache with broken binary
|
|
f'export PATH="{git_bash_path(broken_dir)}:/usr/bin:/bin"',
|
|
'llama-server >/dev/null 2>&1 || true',
|
|
'hash',
|
|
# Now add healthy candidate later in PATH and run reconciliation
|
|
f'export PATH="$HOME/bin:{git_bash_path(broken_dir)}:{git_bash_path(healthy_dir)}:/usr/bin:/bin"',
|
|
]
|
|
_append_llama_server_shim_reconciliation_lines(lines)
|
|
lines.append('llama-server -m /dummy/test.gguf')
|
|
lines.append('hash')
|
|
|
|
res = _run_shell(tmp_path, lines)
|
|
assert res.returncode == 0
|
|
assert "RUN_NATIVE: -m /dummy/test.gguf" in res.stdout
|
|
# Verify hash table ended with healthy binary, not broken
|
|
assert str(healthy_dir / "llama-server") in res.stdout
|
|
|
|
|
|
def test_broken_native_candidate_falls_back_to_healthy_python_compatibility_shim(tmp_path):
|
|
"""Regression: A broken native candidate must not shadow or retire a healthy Python shim."""
|
|
from core.platform_compat import git_bash_path
|
|
broken_dir = tmp_path / "broken_bin"
|
|
_write_mock_native(broken_dir / "llama-server", succeeds=False)
|
|
|
|
shim_file = tmp_path / "bin/llama-server"
|
|
_write_odysseus_shim(shim_file)
|
|
|
|
mock_py_dir = tmp_path / "mock_bin"
|
|
_write_mock_python3(mock_py_dir / "python3", succeeds=True)
|
|
|
|
lines = [
|
|
f'export PATH="$HOME/bin:{git_bash_path(broken_dir)}:{git_bash_path(mock_py_dir)}:/usr/bin:/bin"',
|
|
]
|
|
_append_llama_server_shim_reconciliation_lines(lines)
|
|
lines.append('echo "RESOLVED=$_odysseus_llama_bin"')
|
|
lines.append('command -v llama-server')
|
|
|
|
res = _run_shell(tmp_path, lines)
|
|
assert res.returncode == 0
|
|
assert shim_file.exists(), "Healthy Python compatibility shim must be preserved"
|
|
assert f"RESOLVED={git_bash_path(shim_file)}" in res.stdout
|
|
assert str(shim_file) in res.stdout
|
|
|
|
|
|
def test_broken_native_and_missing_python_backend_sets_preflight_127(tmp_path):
|
|
"""Regression: When the only native candidates are broken and Python server is unavailable,
|
|
finalization must fail closed with ODYSSEUS_PREFLIGHT_EXIT=127 rather than claiming readiness."""
|
|
from core.platform_compat import git_bash_path
|
|
broken_dir = tmp_path / "broken_bin"
|
|
_write_mock_native(broken_dir / "llama-server", succeeds=False)
|
|
|
|
mock_py_dir = tmp_path / "mock_bin"
|
|
_write_mock_python3(mock_py_dir / "python3", succeeds=False)
|
|
|
|
lines = [
|
|
'ODYSSEUS_PREFLIGHT_EXIT=""',
|
|
f'export PATH="$HOME/bin:{git_bash_path(broken_dir)}:{git_bash_path(mock_py_dir)}:/usr/bin:/bin"',
|
|
]
|
|
_append_llama_server_shim_definition_lines(lines)
|
|
_append_llama_server_shim_reconciliation_lines(lines)
|
|
_append_llama_server_finalization_lines(lines)
|
|
lines.append('echo "EXIT=$ODYSSEUS_PREFLIGHT_EXIT"')
|
|
|
|
res = _run_shell(tmp_path, lines)
|
|
assert res.returncode == 0
|
|
assert "EXIT=127" in res.stdout
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_generated_runner_broken_first_healthy_second_e2e(monkeypatch, tmp_path):
|
|
"""Integration regression: The full generated Cookbook runner script must launch the healthy
|
|
native candidate even when an earlier broken candidate exists on PATH."""
|
|
from unittest.mock import AsyncMock, MagicMock
|
|
from types import SimpleNamespace
|
|
from routes.cookbook_helpers import ServeRequest
|
|
import routes.cookbook_routes as cookbook_routes
|
|
from starlette.requests import Request
|
|
from core.platform_compat import git_bash_path
|
|
|
|
fake_home = tmp_path / "fake_home"
|
|
stale_shim = fake_home / "bin/llama-server"
|
|
_write_odysseus_shim(stale_shim)
|
|
|
|
broken_bin = fake_home / "broken/bin/llama-server"
|
|
_write_mock_native(broken_bin, succeeds=False)
|
|
|
|
healthy_bin = fake_home / "healthy/bin/llama-server"
|
|
_write_mock_native(healthy_bin, succeeds=True)
|
|
|
|
tmux_log_dir = tmp_path / "tmux_logs"
|
|
tmux_log_dir.mkdir(parents=True)
|
|
monkeypatch.setattr(cookbook_routes, "TMUX_LOG_DIR", tmux_log_dir)
|
|
monkeypatch.setattr(cookbook_routes, "require_admin", lambda request: None)
|
|
monkeypatch.setattr(cookbook_routes, "_binary_available", AsyncMock(return_value=True))
|
|
monkeypatch.setattr(cookbook_routes, "load_stored_hf_token", lambda **kwargs: "")
|
|
monkeypatch.setattr("core.database.SessionLocal", MagicMock())
|
|
|
|
class _Proc:
|
|
returncode = 0
|
|
stderr = None
|
|
async def wait(self):
|
|
return 0
|
|
monkeypatch.setattr(cookbook_routes.asyncio, "create_subprocess_shell", AsyncMock(return_value=_Proc()))
|
|
|
|
router = cookbook_routes.setup_cookbook_routes()
|
|
endpoint = None
|
|
for route in router.routes:
|
|
if route.path == "/api/model/serve" and "POST" in route.methods:
|
|
endpoint = route.endpoint
|
|
break
|
|
assert endpoint is not None
|
|
|
|
http_req = Request({
|
|
"type": "http",
|
|
"method": "POST",
|
|
"path": "/api/model/serve",
|
|
"headers": [],
|
|
"app": SimpleNamespace(state=SimpleNamespace(auth_manager=SimpleNamespace(
|
|
is_configured=True, is_admin=lambda user: user == "admin"))),
|
|
})
|
|
http_req.state.current_user = "admin"
|
|
http_req.state.local_model_authority = True
|
|
|
|
req = ServeRequest(
|
|
repo_id="test/repo",
|
|
cmd="llama-server -m /dummy/model.gguf --port 8090",
|
|
remote_host=None,
|
|
)
|
|
|
|
resp = await endpoint(http_req, req)
|
|
assert resp["ok"] is True
|
|
session_id = resp["session_id"]
|
|
runner_file = tmux_log_dir / f"{session_id}_run.sh"
|
|
assert runner_file.exists()
|
|
|
|
# Broken is earlier on PATH than healthy
|
|
res = _run_shell(
|
|
fake_home,
|
|
[str(runner_file)],
|
|
path=f"{git_bash_path(fake_home / 'bin')}:{git_bash_path(broken_bin.parent)}:{git_bash_path(healthy_bin.parent)}:/usr/bin:/bin",
|
|
)
|
|
assert res.returncode == 0
|
|
assert not stale_shim.exists(), "Stale shim must have been retired"
|
|
assert "RUN_NATIVE: -m /dummy/model.gguf --port 8090" in res.stdout
|
|
assert "error: missing libllama.so" not in res.stdout
|
|
assert "Native llama-server not found — building from source" not in res.stdout
|