vibe-coding-master 0.8.3 → 0.8.4

package/dist-frontend/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>VibeCodingMaster</title>
-    <script type="module" crossorigin src="/assets/index-C21rIHsU.js"></script>
+    <script type="module" crossorigin src="/assets/index-ClaVB8jM.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-Dc0_KSf4.css">
   </head>
   <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-coding-master",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "description": "Local GUI session cockpit for Claude Code role sessions.",
   "type": "module",
   "files": [
@@ -49,11 +49,14 @@
     "react-dom": "^19.1.0",
     "react-markdown": "^10.1.0",
     "remark-gfm": "^4.0.1",
+    "remark-parse": "^11.0.0",
+    "unified": "^11.0.5",
     "ws": "^8.18.2",
     "zod": "^3.25.28"
   },
   "devDependencies": {
     "@playwright/test": "^1.52.0",
+    "@types/mdast": "^4.0.4",
     "@types/node": "^22.15.24",
     "@types/react": "^19.1.6",
     "@types/react-dom": "^19.1.5",

package/scripts/harness-tools/run-long-check

@@ -17,6 +17,7 @@ Only one validation job may be active at a time.
 """
 import json
 import os
+import shutil
 import signal
 import subprocess
 import sys
@@ -206,7 +207,48 @@ def find_active_job() -> dict | None:
     return None
 
 
+def resolve_executable(executable: str) -> str:
+    root = root_dir()
+    if os.path.dirname(executable):
+        candidate = root / executable
+        if not candidate.exists():
+            raise ValueError(f"executable does not exist: {candidate}")
+        if not candidate.is_file():
+            raise ValueError(f"executable is not a regular file: {candidate}")
+        if not os.access(candidate, os.X_OK):
+            raise ValueError(f"file is not executable: {candidate}")
+        return str(candidate)
+
+    # Popen runs in the worktree root, including for relative PATH entries.
+    search_path = os.pathsep.join(str(root / entry) for entry in os.get_exec_path())
+    resolved = shutil.which(executable, path=search_path)
+    if resolved is None:
+        raise ValueError(f"executable not found or not executable on PATH: {executable}")
+    return resolved
+
+
+def record_launch_failure(directory: Path, status: dict, stage: str, error: OSError) -> str:
+    message = (
+        f"Unable to start {stage} for job {status['jobId']}: "
+        f"command={status['command'][0]!r}, cwd={root_dir()}: {error}"
+    )
+    with (directory / "stderr.log").open("a", encoding="utf-8") as stderr:
+        stderr.write(message + "\n")
+    write_json(
+        directory / "status.json",
+        {**status, "status": "failed", "finishedAt": now_iso(), "exitCode": None},
+    )
+    return message
+
+
 def start_job(command: list[str], timeout_seconds: float) -> int:
+    try:
+        executable = resolve_executable(command[0])
+    except (OSError, ValueError) as error:
+        print(f"error: cannot start {command[0]!r} in {root_dir()}: {error}", file=sys.stderr)
+        return 2
+    command = [executable, *command[1:]]
+
     active = find_active_job()
     if active:
         print(
@@ -234,31 +276,34 @@ def start_job(command: list[str], timeout_seconds: float) -> int:
         )
         + "\n"
     )
-    write_json(
-        directory / "status.json",
-        {
-            "jobId": job,
-            "status": "queued",
-            "command": command,
-            "cwd": ".",
-            "timeoutSeconds": timeout_seconds,
-            "startedAt": None,
-            "finishedAt": None,
-            "exitCode": None,
-            "durationSeconds": None,
-            "workerPid": None,
-            "processId": None,
-        },
-    )
+    queued = {
+        "jobId": job,
+        "status": "queued",
+        "command": command,
+        "cwd": ".",
+        "timeoutSeconds": timeout_seconds,
+        "startedAt": None,
+        "finishedAt": None,
+        "exitCode": None,
+        "durationSeconds": None,
+        "workerPid": None,
+        "processId": None,
+    }
+    write_json(directory / "status.json", queued)
 
-    subprocess.Popen(
-        [sys.executable, str(Path(__file__).resolve()), "--worker", job],
-        cwd=root_dir(),
-        stdin=subprocess.DEVNULL,
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-        start_new_session=True,
-    )
+    try:
+        subprocess.Popen(
+            [sys.executable, str(Path(__file__).resolve()), "--worker", job],
+            cwd=root_dir(),
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+    except OSError as error:
+        message = record_launch_failure(directory, queued, "job worker", error)
+        print(f"error: {message}", file=sys.stderr)
+        return 1
 
     print(f"job: {job}")
     print(f"ceiling: {int(timeout_seconds)}s (worker-enforced)")
@@ -290,30 +335,32 @@ def run_worker(job: str) -> int:
         "timeoutSeconds": timeout_seconds,
         "workerPid": os.getpid(),
     }
-    write_json(
-        status_path,
-        {
-            **base,
-            "status": "starting",
-            "startedAt": None,
-            "finishedAt": None,
-            "exitCode": None,
-            "durationSeconds": None,
-            "processId": None,
-        },
-    )
+    starting = {
+        **base,
+        "status": "starting",
+        "startedAt": None,
+        "finishedAt": None,
+        "exitCode": None,
+        "durationSeconds": None,
+        "processId": None,
+    }
+    write_json(status_path, starting)
 
     started = time.time()
     started_at = now_iso()
     verdict = None
     with (directory / "stdout.log").open("wb") as stdout, (directory / "stderr.log").open("wb") as stderr:
-        process = subprocess.Popen(
-            command,
-            cwd=root_dir(),
-            stdout=stdout,
-            stderr=stderr,
-            start_new_session=True,
-        )
+        try:
+            process = subprocess.Popen(
+                command,
+                cwd=root_dir(),
+                stdout=stdout,
+                stderr=stderr,
+                start_new_session=True,
+            )
+        except OSError as error:
+            record_launch_failure(directory, starting, "validation command", error)
+            return 1
         running = {
             **base,
             "status": "running",