@evref-bl/pharo-agent 0.3.1 → 0.3.3

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pharo-agent",
   "displayName": "Pharo Agent",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "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.3.1",
+  "version": "0.3.3",
   "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.3.1",
+  "version": "0.3.3",
   "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 Pharo tooling in this project.
 From the project root, run the released CLI that matches this plugin:
 
 ```sh
-npx --yes @evref-bl/pharo-agent@0.3.1 init --host codex
+npx --yes @evref-bl/pharo-agent@0.3.3 init --host codex
 ```
 
 Use `--host claude` in Claude Code and `--host opencode` in OpenCode.

package/src/live.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { closeProject, openProject } from "@evref-bl/plexus";
+import { ScopedPharoLauncher, closeProject, openProject } from "@evref-bl/plexus";
 import { callImageTool } from "./gateway.js";
 import {
   defaultImageId,
@@ -13,20 +13,28 @@ import {
   writeOpenImages,
 } from "./runtime.js";
 
-export const pifsRelease = "v0.4.0";
+export const pifsRelease = "v0.4.1";
 
 export function pifsStartCode(mountPath, imageName) {
   return `Metacello new
 	baseline: 'PharoImageFS';
 	repository: 'github://Evref-BL/pharo-image-fs:${pifsRelease}/src';
 	load: 'Core'.
-(PIFSServer
+((Smalltalk globals at: #PIFSServer)
 	startOn: 0
 	mountAt: ${smalltalkString(mountPath)} asFileReference
 	named: ${smalltalkString(imageName)}) port`;
 }
 
 export function resultPrintString(result) {
+  // MCP tool results carry the image's answer as JSON inside a text content part.
+  if (typeof result === "string") {
+    try {
+      return resultPrintString(JSON.parse(result));
+    } catch {
+      return undefined;
+    }
+  }
   if (!result || typeof result !== "object") return undefined;
   if (typeof result.resultPrintString === "string") return result.resultPrintString;
   for (const value of Object.values(result)) {
@@ -36,16 +44,56 @@ export function resultPrintString(result) {
   return undefined;
 }
 
+
+export function needsImageCreation(listed, imageId) {
+  const summary = listed.images.find((image) => image.imageId === imageId);
+  if (!summary) {
+    throw new Error(`PLexus does not know image ${imageId}.`);
+  }
+  // PLexus reports an image it has no runtime state for as declared.
+  return summary.status === "declared";
+}
+
+export function describeLifecycleFailure(failure) {
+  const stderr = failure.launcherResult?.raw?.stderr?.trim();
+  return [
+    `${failure.imageId}: ${failure.message}`,
+    failure.diagnostic,
+    failure.action,
+    stderr ? `launcher: ${stderr.slice(0, 500)}` : undefined,
+  ]
+    .filter(Boolean)
+    .join("\n  ");
+}
+
+// openProject and closeProject throw on failure, carrying the failures on the error.
+export async function runLifecycle(action, fallback) {
+  try {
+    return await action();
+  } catch (error) {
+    const failures = error?.result?.failures;
+    if (!Array.isArray(failures) || failures.length === 0) {
+      throw error;
+    }
+    throw new Error(`${fallback}\n${failures.map(describeLifecycleFailure).join("\n")}`);
+  }
+}
+
 export async function openAgentImage(projectRoot, imageId) {
   const resolved = resolveImageId(projectRoot, imageId);
   const openImages = readOpenImages(projectRoot);
   if (openImages[resolved]) {
     return { alreadyOpen: true, ...openImages[resolved] };
   }
-  const opened = await openProject({ projectRoot, imageIds: [resolved] });
-  if (!opened.ok || opened.failures.length > 0) {
-    throw new Error(opened.failures.map((failure) => failure.message).join("\n") || "PLexus could not open the project image.");
+  const launcher = new ScopedPharoLauncher({ projectRoot });
+  const created = needsImageCreation(launcher.listImages(), resolved);
+  if (created) {
+    await launcher.createImage(resolved);
   }
+  const opened = await runLifecycle(
+    () => openProject({ projectRoot, imageIds: [resolved] }),
+    `PLexus could not open image ${resolved}.`,
+  );
   const { image, mcpServerId } = selectRunningImage(opened.state, resolved);
   const mountPath = resolveMountPath(projectRoot, readConfig(projectRoot), image.id);
   fs.mkdirSync(path.dirname(mountPath), { recursive: true });
@@ -60,10 +108,12 @@ export async function openAgentImage(projectRoot, imageId) {
   });
   const projectionPort = Number(resultPrintString(result));
   if (!Number.isInteger(projectionPort) || projectionPort < 1) {
-    throw new Error("PIFS started but did not report its projection port.");
+    throw new Error(
+      `PIFS did not report a projection port: ${JSON.stringify(result).slice(0, 500)}`,
+    );
   }
   writeOpenImages(projectRoot, { ...openImages, [resolved]: { ...open, projectionPort } });
-  return { imageId: image.id, mountPath, projectionPort };
+  return { imageId: image.id, created, mountPath, projectionPort };
 }
 
 async function closeOneImage(projectRoot, openImages, imageId) {
@@ -71,15 +121,15 @@ async function closeOneImage(projectRoot, openImages, imageId) {
   let projectionError;
   try {
     await callImageTool(projectRoot, open, "image_evaluate", {
-      code: `PIFSServer stopOn: ${open.projectionPort}`,
+      code: `(Smalltalk globals at: #PIFSServer) stopOn: ${open.projectionPort}`,
     });
   } catch (error) {
     projectionError = error;
   }
-  const closed = await closeProject({ projectRoot, imageIds: [imageId] });
-  if (!closed.ok || closed.failures.length > 0) {
-    throw new Error(closed.failures.map((failure) => failure.message).join("\n") || "PLexus could not close the project image.");
-  }
+  const closed = await runLifecycle(
+    () => closeProject({ projectRoot, imageIds: [imageId] }),
+    `PLexus could not close image ${imageId}.`,
+  );
   return { stoppedImages: closed.stoppedImages.map((image) => image.id), projectionError };
 }