paseo-smart-session 1.2.5 → 1.2.6

package/README.md

@@ -37,13 +37,13 @@ That history remains useful after an individual session ends or a provider cache
 Install from npm on Paseo 0.9.0 or newer:
 
 ```sh
-paseo plugin install npm:paseo-smart-session@1.2.5
+paseo plugin install npm:paseo-smart-session@1.2.6
 ```
 
 Paseo 0.8 can install the same plugin from Git:
 
 ```sh
-paseo plugin add tomgrin10/paseo-smart-session --ref v1.2.5
+paseo plugin add tomgrin10/paseo-smart-session --ref v1.2.6
 ```
 
 ```sh

package/mcp.mjs

@@ -71,6 +71,12 @@ const log = (...args) => console.error("[smart-session mcp]", ...args);
  * installed. On a managed Git install the fallback instead finds the `paseo` CLI
  * on `PATH` and resolves the client from its own installed dependencies — the
  * same package the running daemon was built with.
+ *
+ * The desktop app is the exception. Its client lives inside `app.asar`, which
+ * only Electron can read, and its `paseo` is a shell wrapper with no
+ * `node_modules` beside it. `server/install.ts` therefore registers this server
+ * to run on the app's own Electron runtime in node mode, and from there the
+ * client resolves through `process.resourcesPath`.
  */
 let daemonClientModule = null;
 
@@ -78,22 +84,38 @@ const CLIENT_SPECIFIER = ["@getpaseo", "client", "internal", "daemon-client"].jo
 
 async function loadDaemonClient() {
   if (daemonClientModule !== null) return daemonClientModule;
-  try {
-    daemonClientModule = await import(CLIENT_SPECIFIER);
-    return daemonClientModule;
-  } catch (directError) {
-    const cliPath = findPaseoCli();
-    if (cliPath === null) throw directError;
+  const failures = [];
+  for (const { label, resolve } of clientCandidates()) {
     try {
-      const resolved = createRequire(cliPath).resolve(CLIENT_SPECIFIER);
-      daemonClientModule = await import(pathToFileURL(resolved).href);
+      daemonClientModule = await import(resolve());
       return daemonClientModule;
-    } catch (viaCliError) {
-      throw new Error(
-        `Cannot resolve ${CLIENT_SPECIFIER} directly (${directError.message}) or via the paseo CLI at ${cliPath} (${viaCliError.message})`,
-      );
+    } catch (error) {
+      failures.push(`${label} (${error.message})`);
     }
   }
+  throw new Error(`Cannot resolve ${CLIENT_SPECIFIER} ${failures.join(" or ")}${desktopHint()}`);
+}
+
+/** Every place the client can come from, cheapest first. */
+function clientCandidates() {
+  const fromEntry = (entry) => () => pathToFileURL(createRequire(entry).resolve(CLIENT_SPECIFIER)).href;
+  const candidates = [{ label: "directly", resolve: () => CLIENT_SPECIFIER }];
+  // Set only under Electron, where the bundled CLI inside app.asar is readable.
+  if (typeof process.resourcesPath === "string") {
+    const entry = join(process.resourcesPath, "app.asar", "node_modules", "@getpaseo", "cli", "dist", "index.js");
+    candidates.push({ label: `from the Paseo app bundle at ${process.resourcesPath}`, resolve: fromEntry(entry) });
+  }
+  const cliPath = findPaseoCli();
+  if (cliPath !== null) candidates.push({ label: `via the paseo CLI at ${cliPath}`, resolve: fromEntry(cliPath) });
+  return candidates;
+}
+
+/** Explains the one failure a person can fix without reading the code. */
+function desktopHint() {
+  if (process.versions.electron !== undefined) return "";
+  const cliPath = findPaseoCli();
+  if (cliPath === null || !existsSync(join(dirname(cliPath), "..", "app.asar"))) return "";
+  return ". The paseo CLI is the desktop app's, whose client only its own runtime can load: reload the smart-session plugin so it re-registers this MCP server on that runtime, then restart the Claude Code session";
 }
 
 /** Finds `paseo` on PATH and resolves symlinks, the way a shell's `which` would. */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "paseo-smart-session",
   "type": "module",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "license": "MIT",
   "description": "Records Claude plan-usage history and lets a Paseo agent manage its own context.",
   "repository": {

package/server/install.ts

@@ -198,6 +198,45 @@ async function writeAtomic(path: string, text: string): Promise<void> {
   await rename(temp, path);
 }
 
+export interface McpDefinition {
+  type: "stdio";
+  command: string;
+  args: string[];
+  env?: Record<string, string>;
+}
+
+export interface McpRuntime {
+  electron: string | undefined;
+  execPath: string;
+  appImage: string | undefined;
+}
+
+const currentRuntime = (): McpRuntime => ({
+  electron: process.versions.electron,
+  execPath: process.execPath,
+  appImage: process.env.APPIMAGE,
+});
+
+/**
+ * How Claude Code should launch `mcp.mjs`.
+ *
+ * `node` from `PATH`, except under the desktop app. There the daemon client lives
+ * inside `app.asar`, which plain Node cannot read, so the server runs on the
+ * runtime this plugin is itself running on — Electron in node mode, the same way
+ * the app launches its bundled `paseo` CLI. An AppImage mounts at a fresh path on
+ * every launch, so its stable `$APPIMAGE` stands in for the mounted executable.
+ */
+export function mcpDefinition(pluginDir: string, runtime: McpRuntime = currentRuntime()): McpDefinition {
+  const args = [join(pluginDir, "mcp.mjs")];
+  if (runtime.electron === undefined) return { type: "stdio", command: "node", args };
+  return {
+    type: "stdio",
+    command: runtime.appImage ?? runtime.execPath,
+    args,
+    env: { ELECTRON_RUN_AS_NODE: "1" },
+  };
+}
+
 /**
  * Registers the agent-facing MCP server, through Claude Code's own CLI.
  *
@@ -208,34 +247,31 @@ async function writeAtomic(path: string, text: string): Promise<void> {
  * install into a new directory, so an entry can exist while its script no longer
  * does.
  */
-export function mcpPointsAtPlugin(output: string, pluginDir: string): boolean {
+export function mcpPointsAtPlugin(output: string, definition: McpDefinition): boolean {
   const lines = output.split(/\r?\n/).map((line) => line.trim());
   return lines.includes("Scope: User config (available in all your projects)")
-    && lines.includes("Command: node")
-    && lines.includes(`Args: ${join(pluginDir, "mcp.mjs")}`);
+    && lines.includes(`Command: ${definition.command}`)
+    && lines.includes(`Args: ${definition.args.join(" ")}`)
+    && Object.entries(definition.env ?? {}).every(([key, value]) => lines.includes(`${key}=${value}`));
 }
 
 async function ensureMcp(pluginDir: string): Promise<InstallReport["mcp"]> {
   const run = (args: string[]): Promise<{ stdout: string }> =>
     execFileAsync("claude", args, { timeout: 20_000, maxBuffer: 1024 * 1024 });
+  const definition = mcpDefinition(pluginDir);
 
   let existing = false;
   try {
     const { stdout } = await run(["mcp", "get", "smart-session"]);
-    if (mcpPointsAtPlugin(stdout, pluginDir)) return "present";
+    if (mcpPointsAtPlugin(stdout, definition)) return "present";
     existing = true;
   } catch {
     // Absent, or no `claude` on PATH. The add below tells the two apart.
   }
 
-  const definition = JSON.stringify({
-    type: "stdio",
-    command: "node",
-    args: [join(pluginDir, "mcp.mjs")],
-  });
   try {
     if (existing) await run(["mcp", "remove", "smart-session", "--scope", "user"]);
-    await run(["mcp", "add-json", "--scope", "user", "smart-session", definition]);
+    await run(["mcp", "add-json", "--scope", "user", "smart-session", JSON.stringify(definition)]);
     return existing ? "updated" : "added";
   } catch {
     // No `claude` binary on the daemon's PATH is the usual reason, and it is not