oira666_pi-subagent 0.1.6 → 0.1.7

package/index.ts

@@ -411,33 +411,37 @@ export default function (pi: ExtensionAPI) {
   // Auto-discover agents on session start
   pi.on("session_start", async (_event, ctx) => {
     if (!canDelegate) return;
-
-    const discovery = discoverAgents(ctx.cwd, "both");
-    discoveredAgents = discovery.agents;
-
-    if (discoveredAgents.length > 0 && ctx.hasUI) {
-      const list = discoveredAgents
-        .map((a) => `  - ${a.name} (${a.source})`)
-        .join("\n");
-      ctx.ui.notify(
-        `Found ${discoveredAgents.length} subagent(s):\n${list}`,
-        "info",
-      );
+    try {
+      const discovery = discoverAgents(ctx.cwd, "both");
+      discoveredAgents = discovery.agents;
+
+      if (discoveredAgents.length > 0 && ctx.hasUI) {
+        const list = discoveredAgents
+          .map((a) => `  - ${a.name} (${a.source})`)
+          .join("\n");
+        ctx.ui.notify(
+          `Found ${discoveredAgents.length} subagent(s):\n${list}`,
+          "info",
+        );
+      }
+    } catch (err) {
+      console.error("[pi-subagent] Error in session_start:", err);
     }
   });
 
   // Inject available agents into the system prompt
   pi.on("before_agent_start", async (event) => {
-    if (!canDelegate) return;
-    if (discoveredAgents.length === 0) return;
+    try {
+      if (!canDelegate) return;
+      if (discoveredAgents.length === 0) return;
 
-    const agentList = discoveredAgents
-      .map((a) => `- **${a.name}**: ${a.description}`)
-      .join("\n");
-    return {
-      systemPrompt:
-        event.systemPrompt +
-        `\n\n## Available Subagents
+      const agentList = discoveredAgents
+        .map((a) => `- **${a.name}**: ${a.description}`)
+        .join("\n");
+      return {
+        systemPrompt:
+          event.systemPrompt +
+          `\n\n## Available Subagents
 
 The following subagents are available via the \`subagent\` tool:
 
@@ -471,7 +475,10 @@ The tool always accepts a \`tasks\` array:
 - Cycle prevention: ${preventCycles ? "enabled" : "disabled"}
 - Current delegation stack: ${ancestorAgentStack.length > 0 ? ancestorAgentStack.join(" -> ") : "(root)"}
 `,
-    };
+      };
+    } catch (err) {
+      console.error("[pi-subagent] Error in before_agent_start:", err);
+    }
   });
 
   // Register the subagent tool
@@ -498,152 +505,165 @@ The tool always accepts a \`tasks\` array:
       parameters: SubagentParams,
 
       async execute(_toolCallId, params, signal, onUpdate, ctx) {
-        const discovery = discoverAgents(ctx.cwd, "both");
-        const { agents } = discovery;
-
-        const delegationMode = parseDelegationMode(params.mode);
-        if (!delegationMode) {
-          const fallbackDetails = makeDetailsFactory(
-            discovery.projectAgentsDir,
-            DEFAULT_DELEGATION_MODE,
-          );
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Invalid mode \"${String(params.mode)}\". Expected \"spawn\" or \"fork\".\nAvailable agents: ${formatAgentNames(agents)}`,
-              },
-            ],
-            details: fallbackDetails("single")([]),
-            isError: true,
-          };
-        }
-
-        const makeDetails = makeDetailsFactory(
-          discovery.projectAgentsDir,
-          delegationMode,
-        );
+        try {
+          const discovery = discoverAgents(ctx.cwd, "both");
+          const { agents } = discovery;
 
-        let forkSessionSnapshotJsonl: string | undefined;
-        if (delegationMode === "fork") {
-          forkSessionSnapshotJsonl = buildForkSessionSnapshotJsonl(
-            ctx.sessionManager,
-          );
-          if (!forkSessionSnapshotJsonl) {
+          const delegationMode = parseDelegationMode(params.mode);
+          if (!delegationMode) {
+            const fallbackDetails = makeDetailsFactory(
+              discovery.projectAgentsDir,
+              DEFAULT_DELEGATION_MODE,
+            );
             return {
               content: [
                 {
                   type: "text",
-                  text: "Cannot use mode=\"fork\": failed to snapshot current session context.",
+                  text: `Invalid mode \"${String(params.mode)}\". Expected \"spawn\" or \"fork\".\nAvailable agents: ${formatAgentNames(agents)}`,
                 },
               ],
-              details: makeDetails("single")([]),
+              details: fallbackDetails("single")([]),
               isError: true,
             };
           }
-        }
-
-        const tasks = params.tasks ?? [];
-        if (tasks.length === 0) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Invalid parameters. Provide a non-empty tasks array.\nAvailable agents: ${formatAgentNames(agents)}`,
-              },
-            ],
-            details: makeDetails("single")([]),
-          };
-        }
 
-        const executionMode = tasks.length === 1 ? "single" : "parallel";
+          const makeDetails = makeDetailsFactory(
+            discovery.projectAgentsDir,
+            delegationMode,
+          );
 
-        // Security: guard project-local agents before running
-        const requested = new Set<string>();
-        for (const t of tasks) requested.add(t.agent);
+          let forkSessionSnapshotJsonl: string | undefined;
+          if (delegationMode === "fork") {
+            forkSessionSnapshotJsonl = buildForkSessionSnapshotJsonl(
+              ctx.sessionManager,
+            );
+            if (!forkSessionSnapshotJsonl) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: "Cannot use mode=\"fork\": failed to snapshot current session context.",
+                  },
+                ],
+                details: makeDetails("single")([]),
+                isError: true,
+              };
+            }
+          }
 
-        if (preventCycles) {
-          const cycleViolations = getCycleViolations(
-            requested,
-            ancestorAgentStack,
-          );
-          if (cycleViolations.length > 0) {
-            const stackText =
-              ancestorAgentStack.length > 0
-                ? ancestorAgentStack.join(" -> ")
-                : "(root)";
+          const tasks = params.tasks ?? [];
+          if (tasks.length === 0) {
             return {
               content: [
                 {
                   type: "text",
-                  text: `Blocked: delegation cycle detected. Requested agent(s) already in the delegation stack: ${cycleViolations.join(", ")}.
-Current stack: ${stackText}
-
-This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A).`,
+                  text: `Invalid parameters. Provide a non-empty tasks array.\nAvailable agents: ${formatAgentNames(agents)}`,
                 },
               ],
-              details: makeDetails(executionMode)([]),
-              isError: true,
+              details: makeDetails("single")([]),
             };
           }
-        }
 
-        const requestedProjectAgents = getRequestedProjectAgents(
-          agents,
-          requested,
-        );
-        const projectAgentConfirmationSetting =
-          getProjectAgentConfirmationSetting();
-        const projectAgentSessionKey = getProjectAgentSessionKey(
-          discovery.projectAgentsDir,
-        );
-        const shouldConfirmProjectAgents =
-          requestedProjectAgents.length > 0 &&
-          projectAgentConfirmationSetting === "ask" &&
-          !approvedProjectAgentDirsForSession.has(projectAgentSessionKey);
-        if (shouldConfirmProjectAgents) {
-          if (ctx.hasUI) {
-            const approval = await confirmProjectAgentsIfNeeded(
-              requestedProjectAgents,
-              discovery.projectAgentsDir,
-              ctx,
+          const executionMode = tasks.length === 1 ? "single" : "parallel";
+
+          // Security: guard project-local agents before running
+          const requested = new Set<string>();
+          for (const t of tasks) requested.add(t.agent);
+
+          if (preventCycles) {
+            const cycleViolations = getCycleViolations(
+              requested,
+              ancestorAgentStack,
             );
-            if (approval === "no") {
+            if (cycleViolations.length > 0) {
+              const stackText =
+                ancestorAgentStack.length > 0
+                  ? ancestorAgentStack.join(" -> ")
+                  : "(root)";
               return {
                 content: [
                   {
                     type: "text",
-                    text: "Canceled: project-local agents not approved.",
+                    text: `Blocked: delegation cycle detected. Requested agent(s) already in the delegation stack: ${cycleViolations.join(", ")}.
+Current stack: ${stackText}
+
+This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A).`,
                   },
                 ],
                 details: makeDetails(executionMode)([]),
+                isError: true,
               };
             }
-            if (approval === "session") {
-              approvedProjectAgentDirsForSession.add(projectAgentSessionKey);
+          }
+
+          const requestedProjectAgents = getRequestedProjectAgents(
+            agents,
+            requested,
+          );
+          const projectAgentConfirmationSetting =
+            getProjectAgentConfirmationSetting();
+          const projectAgentSessionKey = getProjectAgentSessionKey(
+            discovery.projectAgentsDir,
+          );
+          const shouldConfirmProjectAgents =
+            requestedProjectAgents.length > 0 &&
+            projectAgentConfirmationSetting === "ask" &&
+            !approvedProjectAgentDirsForSession.has(projectAgentSessionKey);
+          if (shouldConfirmProjectAgents) {
+            if (ctx.hasUI) {
+              const approval = await confirmProjectAgentsIfNeeded(
+                requestedProjectAgents,
+                discovery.projectAgentsDir,
+                ctx,
+              );
+              if (approval === "no") {
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: "Canceled: project-local agents not approved.",
+                    },
+                  ],
+                  details: makeDetails(executionMode)([]),
+                };
+              }
+              if (approval === "session") {
+                approvedProjectAgentDirsForSession.add(projectAgentSessionKey);
+              }
+            } else {
+              const names = requestedProjectAgents.map((a) => a.name).join(", ");
+              const dir = discovery.projectAgentsDir ?? "(unknown)";
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Blocked: project-local agent confirmation is required in non-UI mode.\nAgents: ${names}\nSource: ${dir}\n\nSet ${SUBAGENT_CONFIRM_PROJECT_AGENTS_ENV}=false or =session only if this repository is trusted.`,
+                  },
+                ],
+                details: makeDetails(executionMode)([]),
+                isError: true,
+              };
             }
-          } else {
-            const names = requestedProjectAgents.map((a) => a.name).join(", ");
-            const dir = discovery.projectAgentsDir ?? "(unknown)";
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Blocked: project-local agent confirmation is required in non-UI mode.\nAgents: ${names}\nSource: ${dir}\n\nSet ${SUBAGENT_CONFIRM_PROJECT_AGENTS_ENV}=false or =session only if this repository is trusted.`,
-                },
-              ],
-              details: makeDetails(executionMode)([]),
-              isError: true,
-            };
           }
-        }
 
-        if (tasks.length === 1) {
-          const [task] = tasks;
-          return executeSingle(
-            task.agent,
-            task.task,
-            task.cwd,
+          if (tasks.length === 1) {
+            const [task] = tasks;
+            return executeSingle(
+              task.agent,
+              task.task,
+              task.cwd,
+              delegationMode,
+              forkSessionSnapshotJsonl,
+              agents,
+              ctx.cwd,
+              signal,
+              onUpdate,
+              makeDetails,
+            );
+          }
+
+          return await executeParallel(
+            tasks,
             delegationMode,
             forkSessionSnapshotJsonl,
             agents,
@@ -652,18 +672,15 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
             onUpdate,
             makeDetails,
           );
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          const stack = err instanceof Error && err.stack ? `\n\n${err.stack}` : "";
+          return {
+            content: [{ type: "text" as const, text: `[pi-subagent] Unexpected error: ${msg}${stack}` }],
+            details: buildSubagentDetails("single", DEFAULT_DELEGATION_MODE, null, []),
+            isError: true,
+          };
         }
-
-        return executeParallel(
-          tasks,
-          delegationMode,
-          forkSessionSnapshotJsonl,
-          agents,
-          ctx.cwd,
-          signal,
-          onUpdate,
-          makeDetails,
-        );
       },
 
       renderCall: (args, theme) => renderCall(args, theme),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oira666_pi-subagent",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Subagent extension for Pi coding agent. Delegate tasks to specialized agents.",
   "type": "module",
   "main": "index.ts",
@@ -37,8 +37,12 @@
     "access": "public"
   },
   "license": "MIT",
+  "scripts": {
+    "test": "node --import tsx --test test/*.test.ts"
+  },
   "devDependencies": {
     "@types/node": "^25.2.3",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {

package/runner.ts

@@ -241,7 +241,7 @@ const _inheritedCliArgs = parseInheritedCliArgs(process.argv);
 // JSON-line stream processing
 // ---------------------------------------------------------------------------
 
-function processJsonLine(line: string, result: SingleResult): boolean {
+export function processJsonLine(line: string, result: SingleResult): boolean {
   if (!line.trim()) return false;
 
   let event: any;
@@ -251,6 +251,9 @@ function processJsonLine(line: string, result: SingleResult): boolean {
     return false;
   }
 
+  // Guard: JSON.parse can return null, a number, boolean, or array — none of which have .type
+  if (!event || typeof event !== "object" || Array.isArray(event)) return false;
+
   if (event.type === "message_end" && event.message) {
     const msg = event.message as Message;
     result.messages.push(msg);
@@ -524,7 +527,12 @@ export async function runAgent(opts: RunAgentOptions): Promise<SingleResult> {
         resolve(code ?? 0);
       });
 
-      proc.on("error", () => resolve(1));
+      proc.on("error", (err) => {
+        result.stderr += `Spawn error: ${err.message}`;
+        result.stopReason = "error";
+        result.errorMessage = `Failed to spawn pi process: ${err.message}`;
+        resolve(1);
+      });
 
       // Abort handling
       if (signal) {
@@ -559,6 +567,13 @@ export async function runAgent(opts: RunAgentOptions): Promise<SingleResult> {
       }
     }
 
+    return result;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    result.exitCode = result.exitCode === -1 ? 1 : result.exitCode;
+    result.stopReason = result.stopReason ?? "error";
+    result.errorMessage = result.errorMessage ?? msg;
+    if (!result.stderr.trim()) result.stderr = msg;
     return result;
   } finally {
     cleanupTempDir(promptTmpDir);