premanmcp 1.1.2 → 1.1.3

package/bin/eval.js

@@ -1057,7 +1057,9 @@ async function runWithToken(
     // printed a URL and waited out the full timeout for a window it never asked
     // anything to open.
     const resolved = resolveEvalSurface(args, { runId: runs[0].id });
-    const surface = resolved ? { ...resolved, open: () => openUrl(resolved.href) } : null;
+    const surface = resolved
+      ? { ...resolved, open: () => openUrl(resolved.href, { app: resolved.app }) }
+      : null;
     if (surface?.webUrl) say(`Watch it at ${surface.webUrl}`);
     say("");
 

package/bin/link.js

@@ -14,7 +14,7 @@
  * a `git push` is exactly the behaviour that gets a tool uninstalled.
  */
 
-import { desktopAppInstalled, installedDesktopVersion } from "./desktop.js";
+import { desktopAppInstalled, installedAppPath, installedDesktopVersion } from "./desktop.js";
 import { DEFAULT_FRONTEND, frontendUrl, pairedFrontendUrl } from "./shared.js";
 
 export { installedDesktopVersion };
@@ -158,6 +158,10 @@ export function resolveEvalSurface(args, { runId = "", destination = "/Applicati
  * safe when routing is not: no build can misread it, and no dashboard can be
  * the wrong one, because none is named. It cannot land you on the run, and the
  * caller says so rather than implying otherwise.
+ *
+ * Which is why it now ranks below a browser link rather than above one: "cannot
+ * land you on the run" is a real cost, and it is only worth paying when the
+ * alternative is nothing at all. See the ordering in `resolveSurface`.
  */
 function resolveSurface(
   args,
@@ -167,23 +171,32 @@ function resolveSurface(
   const base = requirePairing ? pairedFrontendUrl(args) : frontendUrl(args);
   const webUrl = base ? `${base}${route}` : "";
   const installed = desktopAppInstalled(destination);
+  const app = installed ? installedAppPath(destination) : "";
 
   if (base === DEFAULT_FRONTEND && installed && desktopSupportsRouting(destination)) {
     return {
       href: `preman://open?source=${source}&route=${encodeURIComponent(route)}`,
       webUrl,
+      app,
       surface: "desktop",
     };
   }
 
-  // Deliberately ahead of the "no dashboard is known" return below: not knowing
-  // which browser page holds the run says nothing about whether the app is
-  // installed, and raising it is still the most useful thing available.
-  if (preferApp && installed) {
-    return { href: `preman://open?source=${source}`, webUrl, surface: "desktop-raise" };
+  // A raise is now the last resort rather than the second choice, and only when
+  // there is no page to send anyone to instead.
+  //
+  // It was ahead of the web branch on the reasoning that somebody watching an
+  // eval is already sitting in front of the app. True, but it trades a link
+  // that lands on the run for a window that lands wherever it was left --
+  // which, for an app too old to route, is the one thing it can never be. What
+  // that bought in practice was a stale view and the question "where is my
+  // run", while the browser would have shown it. Raising still beats nothing,
+  // so it survives for the case where no dashboard is known at all.
+  if (!base) {
+    return preferApp && installed
+      ? { href: `preman://open?source=${source}`, webUrl, app, surface: "desktop-raise" }
+      : null;
   }
-
-  if (!base) return null;
   if (base !== DEFAULT_FRONTEND) return { href: webUrl, webUrl, surface: "web-local" };
   return { href: webUrl, webUrl, surface: "web" };
 }

package/bin/runner.js

@@ -467,7 +467,7 @@ export async function runLeasedEval(args, state, job, { log = () => {}, headless
     log,
     headless,
     projectPath: state.project_path || process.cwd(),
-    surface: { ...surface, open: () => openUrl(surface.href) },
+    surface: { ...surface, open: () => openUrl(surface.href, { app: surface.app }) },
   });
   if (result.reason === "lease_lost") log(`eval ${job.id} was taken over or cancelled`);
   else log(`eval ${job.id} finished: ${result.ok ? "ok" : "failed"}`);

package/bin/shared.js

@@ -340,15 +340,25 @@ export function pairedFrontendUrl(args) {
  * ever a convenience — a suite that exercises these flows should not be able to
  * throw tabs at whoever is running it.
  */
-export function openUrl(url) {
+export function openUrl(url, { app = "" } = {}) {
   const optOut = (process.env.PREMAN_NO_BROWSER || "").trim().toLowerCase();
   if (optOut && !["0", "false", "no"].includes(optOut)) return false;
   if (!process.stdout.isTTY) return false;
 
   const opener =
     process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  // `app` names the bundle that must receive the URL, and is the difference
+  // between "a PreMan window" and "the PreMan window we checked". A custom
+  // scheme is claimed, not owned: every build that ever ran on this machine
+  // registers `preman:`, including one in the Trash and any dev copy started
+  // from a checkout, and LaunchServices picks among them by its own rules. So
+  // the CLI inspected the app in /Applications, decided from its version what
+  // the link could do, and then handed the URL to whichever claimant won --
+  // which on this machine was a dev build pointed at a local backend that was
+  // not running. `open -a` addresses the bundle directly and skips the auction.
+  const argv = app && process.platform === "darwin" ? ["-a", app, url] : [url];
   try {
-    const child = spawn(opener, [url], {
+    const child = spawn(opener, argv, {
       stdio: "ignore",
       detached: true,
       shell: process.platform === "win32",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "premanmcp",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "PreMan CLI and stdio proxy for PreMan's hosted MCP server",
   "type": "module",
   "bin": {