paseo-smart-session 1.2.4 → 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
+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
+paseo plugin add tomgrin10/paseo-smart-session --ref v1.2.6
 ```
 
 ```sh

package/client/pill.tsx

@@ -197,9 +197,27 @@ function AutoCompactIcon({
   return <Icon name="FoldVertical" size={size} color={color} />;
 }
 
-/** The lean shape this needs from the agent list, which carries far more. */
+/** The lean shapes this needs from the agent directory, which carries far more. */
+interface ListedAgent {
+  readonly id?: string;
+  readonly workspaceId?: string | null;
+}
+
+interface AgentUpdate {
+  readonly kind: "remove" | "upsert";
+  readonly agentId?: string;
+  readonly agent?: ListedAgent;
+}
+
 interface AgentListing {
-  readonly entries?: readonly { readonly agent?: { id?: string; workspaceId?: string | null } }[];
+  readonly entries?: readonly { readonly agent?: ListedAgent }[];
+  readonly subscription?: {
+    subscribe(observer: {
+      snapshot(listing: AgentListing): void;
+      update(message: { readonly type?: string; readonly payload?: AgentUpdate }): void;
+    }): () => void;
+    release(): Promise<void>;
+  };
 }
 
 /**
@@ -227,6 +245,10 @@ function updatePill(handle: PillHandle, title: string): void {
 export function contributeClient(client: PluginClientContext) {
   /** Every agent this app knows of, and its pill registration while one is up. */
   const tracked = new Map<string, { workspaceId: string; handle: PillHandle | null }>();
+  const lifetime = new AbortController();
+  let stopped = false;
+  let unsubscribeOwnedObservation: (() => void) | null = null;
+  let releaseAgentObservation: (() => Promise<void>) | null = null;
 
   function register(agentId: string, entry: { workspaceId: string; handle: PillHandle | null }): void {
     const toggle = async () => {
@@ -299,42 +321,114 @@ export function contributeClient(client: PluginClientContext) {
     tracked.delete(agentId);
   }
 
+  function applyAgentUpdate(update: AgentUpdate): void {
+    if (update.kind === "remove") {
+      if (typeof update.agentId === "string") forget(update.agentId);
+      return;
+    }
+    const agent = update.agent;
+    if (
+      typeof agent?.id !== "string" ||
+      typeof agent.workspaceId !== "string" ||
+      agent.workspaceId === ""
+    ) return;
+    track(agent.id, agent.workspaceId);
+  }
+
+  function trackAgents(entries: AgentListing["entries"]): Set<string> {
+    const present = new Set<string>();
+    for (const entry of entries ?? []) {
+      const agent = entry.agent;
+      if (
+        typeof agent?.id !== "string" ||
+        typeof agent.workspaceId !== "string" ||
+        agent.workspaceId === ""
+      ) continue;
+      present.add(agent.id);
+      track(agent.id, agent.workspaceId);
+    }
+    return present;
+  }
+
+  /** A restored observation replaces its directory snapshot, including removals. */
+  function replaceAgents(entries: AgentListing["entries"]): void {
+    const present = trackAgents(entries);
+    for (const agentId of [...tracked.keys()]) {
+      if (!present.has(agentId)) forget(agentId);
+    }
+  }
+
   const refresh = () => refreshPills(() => client.rpc(enrolmentState, {}));
 
   const unsubscribeStore = subscribe(sync);
 
-  const unsubscribeAgents = client.paseo.agents.subscribe((update) => {
-    if (update.kind === "remove") {
-      forget(update.agentId);
-      return;
-    }
-    const { id, workspaceId } = update.agent;
-    if (typeof workspaceId !== "string" || workspaceId === "") return;
-    track(id, workspaceId);
+  // v0.8 returns only the listing and emits its subscribed updates through this
+  // local listener. Keep it attached until a newer runtime gives us the owned
+  // observation whose snapshots can reconcile the whole directory on reconnect.
+  let unsubscribeLegacyAgents: (() => void) | null = client.paseo.agents.subscribe((update) => {
+    applyAgentUpdate(update as AgentUpdate);
   });
 
   // The subscription only carries agents that report in from now on, and an idle
   // one may not do that for hours.
   void (async () => {
     try {
-      const listing = (await client.paseo.agents.list()) as unknown as AgentListing;
-      for (const entry of listing.entries ?? []) {
-        const agent = entry.agent;
-        if (typeof agent?.id !== "string" || typeof agent.workspaceId !== "string") continue;
-        track(agent.id, agent.workspaceId);
+      // `agents.subscribe()` listens only to observations already owned by
+      // this API instance. A plain list stopped receiving newly created agents
+      // in Paseo 0.9, which made both plugin pills disappear on new sessions.
+      const listAgents = client.paseo.agents.list as unknown as (options: {
+        subscribe: Record<string, never>;
+        signal: AbortSignal;
+      }) => Promise<AgentListing>;
+      const listing = await listAgents({ subscribe: {}, signal: lifetime.signal });
+      const release = listing.subscription
+        ? () => listing.subscription!.release()
+        : null;
+      if (stopped) {
+        await release?.();
+        return;
+      }
+      releaseAgentObservation = release;
+      // The legacy listener was already live while this snapshot was in flight,
+      // so bootstrap must be additive or it can erase a just-created agent.
+      trackAgents(listing.entries);
+      if (listing.subscription) {
+        unsubscribeOwnedObservation = listing.subscription.subscribe({
+          snapshot(snapshot) {
+            if (!stopped) replaceAgents(snapshot.entries);
+          },
+          update(message) {
+            if (!stopped && message.type === "agent_update" && message.payload) {
+              applyAgentUpdate(message.payload);
+            }
+          },
+        });
+        unsubscribeLegacyAgents?.();
+        unsubscribeLegacyAgents = null;
       }
     } catch {
-      // Not fatal: the subscription still picks up every agent that speaks next.
+      const release = releaseAgentObservation;
+      releaseAgentObservation = null;
+      await release?.().catch(() => undefined);
+      // Not fatal to the rest of the client contribution; a reload can retry.
     }
   })();
 
   void refresh().catch(() => undefined);
   const timer = setInterval(() => void refresh().catch(() => undefined), REFRESH_MS);
 
-  return () => {
+  return async () => {
+    stopped = true;
+    lifetime.abort();
     clearInterval(timer);
-    unsubscribeAgents();
+    unsubscribeLegacyAgents?.();
+    unsubscribeLegacyAgents = null;
+    unsubscribeOwnedObservation?.();
+    unsubscribeOwnedObservation = null;
     unsubscribeStore();
     for (const agentId of [...tracked.keys()]) forget(agentId);
+    const release = releaseAgentObservation;
+    releaseAgentObservation = null;
+    await release?.().catch(() => undefined);
   };
 }

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.4",
+  "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