@hienlh/ppm 0.19.0 → 0.19.1

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [0.19.1] - 2026-09-09
+
+### Fixed
+- **Remote Desktop no longer claims ffmpeg is missing on a Mac that has it** — a PPM started by launchd inherits a bare `PATH` without `/opt/homebrew/bin`; ffmpeg is now also looked for in the usual Homebrew / winget / chocolatey / apt locations, and a "not installed" answer is re-checked instead of being cached until restart, so the checklist really does update once `brew install ffmpeg` finishes.
+- **"Session not found" when opening a terminal from outside a project** — the remote-desktop checklist's install button opened a shell with no project; such a terminal now starts in your home directory.
+
 ## [0.19.0] - 2026-09-08
 
 ### Added

package/assets/skills/ppm/SKILL.md

@@ -71,4 +71,4 @@ This skill covers the `ppm` CLI, its HTTP API, and its config DB. It does **not*
 - Third-party extensions (inspect via `ppm ext list`).
 - The Claude Agent SDK internals (separate skill).
 
-<!-- Generated for PPM v0.19.0 at build time. Re-run `ppm export skill --install` to refresh. -->
+<!-- Generated for PPM v0.19.1 at build time. Re-run `ppm export skill --install` to refresh. -->

package/assets/skills/ppm/references/http-api.md

@@ -335,4 +335,4 @@ _Base URL: `http://localhost:8080` (default; override via `ppm config set port <
 - `ws://<host>/ws/terminal` — PTY terminal multiplexer
 - `ws://<host>/ws/extensions` — extension host channel
 
-<!-- Generated from src/server/routes/ for PPM v0.19.0 -->
+<!-- Generated from src/server/routes/ for PPM v0.19.1 -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hienlh/ppm",
-  "version": "0.19.0",
+  "version": "0.19.1",
   "description": "Personal Project Manager — mobile-first web IDE with AI assistance",
   "author": "hienlh",
   "license": "SEE LICENSE IN LICENSE",

package/src/server/ws/terminal.ts

@@ -1,4 +1,5 @@
 import { statSync } from "node:fs";
+import { homedir } from "node:os";
 import { terminalService } from "../../services/terminal.service.ts";
 import { resolveProjectPath } from "../helpers/resolve-project.ts";
 import { assertAllowed, resolvePath } from "../../services/fs-path-guard.service.ts";
@@ -7,6 +8,9 @@ import { assertAllowed, resolvePath } from "../../services/fs-path-guard.service
  * Where a new shell starts. An explicit `cwd` (explorer "Open in Terminal") wins
  * over the project root and goes through the same allowlist as the filesystem
  * API, so a terminal cannot be spawned anywhere the explorer could not browse.
+ * Neither given (a project-less "run this command" — the remote-desktop
+ * checklist's `brew install ffmpeg` button) → the user's home, the same place the
+ * OS explorer starts browsing from.
  */
 function resolveStartDir(projectName: string | undefined, cwd: string | undefined): string {
   if (cwd) {
@@ -16,7 +20,7 @@ function resolveStartDir(projectName: string | undefined, cwd: string | undefine
     return resolved;
   }
   if (projectName) return resolveProjectPath(projectName);
-  throw new Error("Session not found");
+  return homedir();
 }
 
 /** Control message prefix for resize commands */
@@ -36,8 +40,10 @@ export const terminalWebSocket = {
 
     let session = id !== "new" ? terminalService.get(id) : undefined;
 
-    // If session doesn't exist and a start directory is known, create one
-    if (!session && (projectName || cwd)) {
+    // A fresh socket ("new") always gets a shell — project root, explicit cwd, or home — and
+    // so does a stale id that still knows its project/cwd (tab reopened after a restart).
+    // Only a stale id with no context left is "Session not found".
+    if (!session && (id === "new" || projectName || cwd)) {
       try {
         const startDir = resolveStartDir(projectName, cwd);
         // Create session with the requested ID — but TerminalService generates its own ID.

package/src/services/media-transcode/ffmpeg-capabilities.ts

@@ -2,9 +2,15 @@
  * Discover ffmpeg/ffprobe on this machine and pick the fastest working H.264 encoder.
  *
  * ffmpeg is an *optional* dependency: without it PPM still plays browser-native
- * media (mp4/webm) via Range requests, it just cannot transcode AVI/MKV. The
- * result is cached for the process lifetime — the binary does not appear
- * mid-session, and probing hardware encoders costs a real encode each.
+ * media (mp4/webm) via Range requests, it just cannot transcode AVI/MKV. A
+ * positive result is cached for the process lifetime — probing hardware encoders
+ * costs a real encode each. A *negative* result is not: the remote-desktop
+ * checklist tells the user to install ffmpeg and promises to notice, so "not
+ * found" is re-checked on every call (one `which` + a few `stat`s).
+ *
+ * `PATH` alone is not enough to find it. A daemon started by launchd inherits
+ * `/usr/bin:/bin:/usr/sbin:/sbin` — Homebrew's `/opt/homebrew/bin` is not on it —
+ * so the well-known install directories are probed after `Bun.which`.
  *
  * Hardware encoders are verified by encoding a few synthetic frames rather than by
  * grepping `ffmpeg -encoders`: the list only says the build was compiled with
@@ -60,11 +66,42 @@ async function encoderWorks(ffmpeg: string, encoder: string): Promise<boolean> {
   }
 }
 
+/** Where package managers put ffmpeg when it is not on the daemon's PATH. */
+function wellKnownBinDirs(): string[] {
+  switch (process.platform) {
+    case "darwin": return ["/opt/homebrew/bin", "/usr/local/bin", "/opt/local/bin"];
+    case "win32": {
+      const local = process.env.LOCALAPPDATA;
+      return [
+        ...(local ? [`${local}\\Microsoft\\WinGet\\Links`] : []),
+        "C:\\ProgramData\\chocolatey\\bin", "C:\\ffmpeg\\bin",
+      ];
+    }
+    default: return ["/usr/local/bin", "/usr/bin", "/snap/bin", `${process.env.HOME ?? ""}/.local/bin`];
+  }
+}
+
+/** `Bun.which` on `searchPath` (the process PATH by default) first, then the well-known
+ *  directories. Exported for tests. */
+export function findFfmpegBinary(
+  name: "ffmpeg" | "ffprobe",
+  dirs: string[] = wellKnownBinDirs(),
+  searchPath: string | undefined = process.env.PATH,
+): string | null {
+  const onPath = Bun.which(name, searchPath ? { PATH: searchPath } : undefined);
+  if (onPath) return onPath;
+  for (const dir of dirs) {
+    const found = Bun.which(name, { PATH: dir });
+    if (found) return found;
+  }
+  return null;
+}
+
 let cached: Promise<FfmpegCapabilities> | null = null;
 
 async function detect(): Promise<FfmpegCapabilities> {
-  const ffmpeg = Bun.which("ffmpeg");
-  const ffprobe = Bun.which("ffprobe");
+  const ffmpeg = findFfmpegBinary("ffmpeg");
+  const ffprobe = findFfmpegBinary("ffprobe");
   if (!ffmpeg) return { ffmpeg: null, ffprobe, encoder: null };
   for (const candidate of encoderCandidates()) {
     if (await encoderWorks(ffmpeg, candidate)) return { ffmpeg, ffprobe, encoder: candidate };
@@ -72,10 +109,14 @@ async function detect(): Promise<FfmpegCapabilities> {
   return { ffmpeg, ffprobe, encoder: null };
 }
 
-/** Cached capability lookup; the first call pays for the encoder probes. */
+/** Cached capability lookup; the first call that finds ffmpeg pays for the encoder probes.
+ *  "Not installed" is never cached — the user may be running `brew install ffmpeg` right now. */
 export function getFfmpegCapabilities(): Promise<FfmpegCapabilities> {
   if (!cached) {
-    cached = detect().catch((e) => {
+    cached = detect().then((caps) => {
+      if (!caps.ffmpeg) cached = null;
+      return caps;
+    }).catch((e) => {
       cached = null; // let a later call retry after an unexpected failure
       throw e;
     });