@evref-bl/pharo-agent 0.13.0 → 0.13.1

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pharo-agent",
   "displayName": "Pharo Agent",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "description": "Terminal-first Pharo image setup for coding agents.",
   "author": {
     "name": "Evref-BL",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evref-bl/pharo-agent",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "private": false,
   "description": "Terminal-first Pharo integration for coding agents.",
   "license": "Apache-2.0",

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "pharo-agent",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "description": "Terminal-first Pharo image setup for coding agents.",
   "author": {
     "name": "Evref-BL",

package/skills/pharo-setup/SKILL.md

@@ -8,7 +8,7 @@ Run this only when the user asks to enable or refresh Pharo tooling in this proj
 From the project root, run the released CLI that matches this plugin:
 
 ```sh
-npx --yes @evref-bl/pharo-agent@0.13.0 init --host claude
+npx --yes @evref-bl/pharo-agent@0.13.1 init --host claude
 ```
 
 Name the host this chat runs in: `--host claude` in Claude Code,

package/src/help.js

@@ -11,7 +11,8 @@ const commands = {
   "image list": {
     usage: "image list",
     description: "List the project's declared images and the default one, with the mount and\n"
-      + "projection port of each image this project has running.",
+      + "projection port of each image this project has running. An image this project\n"
+      + "started that has since exited is listed as exited.",
     example: "image list",
   },
   "image templates": {

package/src/images.js

@@ -1,6 +1,12 @@
 import { declareProjectImage, removeProjectImage } from "@evref-bl/plexus";
 import { configuredImages } from "./project.js";
-import { defaultImageId, readConfig, readRunningImages, writeConfig } from "./runtime.js";
+import {
+  defaultImageId,
+  readConfig,
+  readRunningImages,
+  recordedImageIsRunning,
+  writeConfig,
+} from "./runtime.js";
 
 export const defaultLoadScript = "pharo/load-mcp.st";
 
@@ -26,14 +32,20 @@ export function listImages(projectRoot) {
   return {
     ...(defaultImage ? { defaultImage } : {}),
     images: configured.map((image) => {
+      const record = running[image.id];
+      // A record says this project started the image, not that it is still
+      // there. One that crashed or was closed keeps its record until it is
+      // started or stopped again, and its route and mount lead nowhere.
+      const alive = record !== undefined && recordedImageIsRunning(record);
       // The record repeats the id it is keyed by; everything else in it is
       // runtime detail this list carries when the image is running.
-      const { imageId: _keyed, ...runtime } = running[image.id] ?? {};
+      const { imageId: _keyed, ...runtime } = alive ? record : {};
       return {
         id: image.id,
         imageName: image.imageName,
         isDefault: image.id === defaultImage,
-        running: Boolean(running[image.id]),
+        running: alive,
+        ...(record !== undefined && !alive ? { exited: true } : {}),
         ...runtime,
         templateName: image.create?.templateName,
         templateCategory: image.create?.templateCategory,

package/src/live.js

@@ -22,7 +22,7 @@ import {
   writeRunningImages,
 } from "./runtime.js";
 
-export const pifsRelease = "v0.9.2";
+export const pifsRelease = "v0.10.0";
 
 // fuse-t ships as a macOS installer package, so it lands in /usr/local
 // whatever Homebrew's prefix is. The unversioned symlink is what the daemon
@@ -86,6 +86,58 @@ export function pifsStopCode(projectionPort) {
   return `(Smalltalk globals at: #PIFSServer) stopOn: ${projectionPort}`;
 }
 
+// `mount` prints one "<source> on <path> (<options>)" line per mount, with the
+// path resolved, so a project under a symlink is looked for by its real path.
+export function isMountedAt(mountPath, mountTable) {
+  let realPath = mountPath;
+  try {
+    realPath = path.join(fs.realpathSync(path.dirname(mountPath)), path.basename(mountPath));
+  } catch {
+    // No parent directory, so nothing can be mounted there either.
+  }
+  return mountTable
+    .split("\n")
+    .some((line) => line.includes(` on ${mountPath} (`) || line.includes(` on ${realPath} (`));
+}
+
+function currentMountTable() {
+  return spawnSync("mount", [], { encoding: "utf8" }).stdout ?? "";
+}
+
+function unmount(mountPath) {
+  // What PIFSServer>>stopDaemon runs when it stops a projection itself.
+  if (spawnSync("umount", [mountPath], { stdio: "ignore" }).status !== 0) {
+    spawnSync("diskutil", ["unmount", mountPath], { stdio: "ignore" });
+  }
+}
+
+/**
+ * Unmount a projection whose image is gone.
+ *
+ * The mount is served by a PIFS daemon, a process of its own that reads the
+ * source over HTTP from the image. PIFS unmounts it from inside the image when
+ * it stops, which an image that crashed or was closed never does: the mount
+ * stays, every read in it fails with an I/O error, and it holds the path
+ * against the next projection. Unmounting is enough; the daemon exits with its
+ * mount.
+ *
+ * @param {string | undefined} mountPath
+ * @param {{ mountTable?: () => string, unmount?: (path: string) => void }} [host]
+ * @returns {boolean} whether something was unmounted
+ */
+export function releaseProjectionMount(mountPath, host = {}) {
+  const mountTable = host.mountTable ?? currentMountTable;
+  if (mountPath === undefined || !isMountedAt(mountPath, mountTable())) return false;
+  (host.unmount ?? unmount)(mountPath);
+  if (isMountedAt(mountPath, mountTable())) {
+    throw new Error(
+      `The source projection of an image that is gone is still mounted at ${mountPath},`
+        + ` and could not be unmounted. Run umount ${JSON.stringify(mountPath)}, then try again.`,
+    );
+  }
+  return true;
+}
+
 function namedPrintString(value) {
   // Structured results name the print string, somewhere under the envelope,
   // and reach us either as an object or as JSON inside a text part.
@@ -208,6 +260,11 @@ export async function startAgentImage(projectRoot, imageId) {
     restarted = true;
   }
   if (projectionAvailability().available) {
+    // This project has no live image at this mount path now: none was
+    // recorded, or the one recorded has exited. Whatever is still mounted
+    // there was left by an image that is gone, and would hold the path
+    // against the projection about to be mounted.
+    releaseProjectionMount(resolveMountPath(projectRoot, readConfig(projectRoot), resolved));
     fetchPifsRelease(pifsCloneDirectory(projectRoot));
   }
   const launcher = new ScopedPharoLauncher({ projectRoot });
@@ -319,9 +376,14 @@ async function stopOneImage(projectRoot, runningImages, imageId) {
   // ask over either.
   if (record.projectionPort !== undefined) {
     try {
-      await callImageTool(projectRoot, record, "image_evaluate", {
-        code: pifsStopCode(record.projectionPort),
-      });
+      if (recordedImageIsRunning(record)) {
+        await callImageTool(projectRoot, record, "image_evaluate", {
+          code: pifsStopCode(record.projectionPort),
+        });
+      } else {
+        // PIFS stops a projection from inside its image, and this one is gone.
+        releaseProjectionMount(record.mountPath);
+      }
     } catch (error) {
       projectionError = error;
     }

package/src/mcpServer.js

@@ -98,7 +98,8 @@ const projectTools = [
     name: "image_list",
     description:
       "List this project's declared images, which are running, and the route "
-      + "and mount of each running one.",
+      + "and mount of each running one. An image that was started and has "
+      + "exited since is listed as exited; image_start starts it again.",
     inputSchema: { type: "object", properties: {} },
   },
   {
@@ -133,8 +134,17 @@ async function runningImageTools(projectRoot, defaultImage) {
     // contributes no tools yet and the lifecycle tools say how to change that.
     return [];
   }
-  return (await listImageTools(projectRoot, running))
-    .map((tool) => withImageSelector(tool, running.imageId));
+  try {
+    return (await listImageTools(projectRoot, running))
+      .map((tool) => withImageSelector(tool, running.imageId));
+  } catch (error) {
+    // A record says this project started the image, not that it still
+    // answers: it may have exited, or hung. Failing the whole list would take
+    // image_start with it, and with it the one way back. image_list says
+    // which image is gone; stderr reaches the host's log.
+    console.error(`pharo-agent: image ${running.imageId} listed no tools: ${error.message}`);
+    return [];
+  }
 }
 
 // A schema is a description, not a guard: nothing between the model and here