@fcannizzaro/exocommand 1.0.10 → 1.1.0

package/dist/server.js

@@ -2,9 +2,12 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod/v4";
 import { loadCommands } from "./config.js";
 import { executeCommand } from "./executor.js";
-const CONFIG_PATH = process.env.EXO_COMMAND_FILE || "./.exocommand";
 export function createServer(logger, options) {
-    const taskMode = options?.taskMode ?? false;
+    const configPath = options.configPath;
+    const taskMode = options.taskMode ?? false;
+    const tui = options.tui ?? null;
+    const agentId = options.agentId ?? 0;
+    const projectKey = options.projectKey ?? "";
     const activeExecutions = new Map();
     // Build server options conditionally based on mode
     const serverOptions = taskMode
@@ -29,7 +32,7 @@ export function createServer(logger, options) {
         description: "List all available commands defined in the .exocommand config file",
     }, async () => {
         try {
-            const commands = await loadCommands(CONFIG_PATH);
+            const commands = await loadCommands(configPath);
             logger.info("listCommands", `found ${commands.length} command(s)`);
             return {
                 content: [
@@ -58,10 +61,10 @@ export function createServer(logger, options) {
         }
     });
     if (taskMode) {
-        registerTaskMode(server, logger, activeExecutions);
+        registerTaskMode(server, logger, activeExecutions, configPath, tui, agentId, projectKey);
     }
     else {
-        registerSyncMode(server, logger, activeExecutions);
+        registerSyncMode(server, logger, activeExecutions, configPath, tui, agentId, projectKey);
     }
     return server;
 }
@@ -80,17 +83,17 @@ function buildTaskServerOptions(activeExecutions) {
         defaultTaskPollInterval: 1000,
     };
 }
-function registerTaskMode(server, logger, activeExecutions) {
+function registerTaskMode(server, logger, activeExecutions, configPath, tui, agentId, projectKey) {
     // Lazy-loaded to avoid pulling task dependencies when not needed
     const { registerTaskExecute } = require("./task.js");
-    registerTaskExecute(server, logger, activeExecutions);
+    registerTaskExecute(server, logger, activeExecutions, configPath, tui, agentId, projectKey);
 }
 function getTaskContext(activeExecutions) {
     const { createTaskContext } = require("./task.js");
     return createTaskContext(activeExecutions);
 }
 // -- Sync mode: streaming via extra.sendNotification() --------------------
-function registerSyncMode(server, logger, activeExecutions) {
+function registerSyncMode(server, logger, activeExecutions, configPath, tui, agentId, projectKey) {
     server.registerTool("execute", {
         title: "Execute Command",
         description: "Execute a predefined command by name. Streams stdout and stderr line-by-line as logging notifications on the response stream.",
@@ -103,12 +106,15 @@ function registerSyncMode(server, logger, activeExecutions) {
                 .describe("Maximum execution time in seconds. If exceeded, the command is killed and buffered output is returned."),
         },
     }, async ({ name: commandName, timeout }, extra) => {
+        const executionId = crypto.randomUUID();
         logger.warn("execute", `running "${commandName}"`);
+        tui?.addExecution(executionId, commandName, agentId, projectKey);
         let commands;
         try {
-            commands = await loadCommands(CONFIG_PATH);
+            commands = await loadCommands(configPath);
         }
         catch (err) {
+            tui?.updateExecution(executionId, "error");
             return {
                 content: [{
                         type: "text",
@@ -120,6 +126,7 @@ function registerSyncMode(server, logger, activeExecutions) {
         const cmd = commands.find((c) => c.name === commandName);
         if (!cmd) {
             const available = commands.map((c) => c.name).join(", ");
+            tui?.updateExecution(executionId, "error");
             return {
                 content: [{
                         type: "text",
@@ -128,7 +135,6 @@ function registerSyncMode(server, logger, activeExecutions) {
                 isError: true,
             };
         }
-        const executionId = crypto.randomUUID();
         const ac = new AbortController();
         activeExecutions.set(executionId, ac);
         // Propagate request cancellation
@@ -165,6 +171,7 @@ function registerSyncMode(server, logger, activeExecutions) {
                 const status = timedOut
                     ? `Command "${commandName}" timed out after ${timeout}s.`
                     : `Command "${commandName}" was cancelled.`;
+                tui?.updateExecution(executionId, timedOut ? "timeout" : "cancelled");
                 logger.warn("execute", `"${commandName}" ${timedOut ? "timed out" : "was cancelled"}`);
                 return {
                     content: [{
@@ -176,6 +183,7 @@ function registerSyncMode(server, logger, activeExecutions) {
             }
             if (result.exitCode !== 0) {
                 const status = `Command "${commandName}" exited with code ${result.exitCode}`;
+                tui?.updateExecution(executionId, "error");
                 logger.error("execute", `"${commandName}" exited with code ${result.exitCode}`);
                 return {
                     content: [{
@@ -185,6 +193,7 @@ function registerSyncMode(server, logger, activeExecutions) {
                     isError: true,
                 };
             }
+            tui?.updateExecution(executionId, "success");
             logger.success("execute", `"${commandName}" completed (exit code 0)`);
             return {
                 content: [{
@@ -198,6 +207,7 @@ function registerSyncMode(server, logger, activeExecutions) {
         catch (err) {
             const output = lines.join("\n");
             const status = `Command "${commandName}" failed: ${err.message}`;
+            tui?.updateExecution(executionId, "error");
             logger.error("execute", `"${commandName}" failed: ${err.message}`);
             return {
                 content: [{

package/dist/task.js

@@ -3,7 +3,6 @@ import { InMemoryTaskStore, InMemoryTaskMessageQueue, } from "@modelcontextproto
 import { z } from "zod/v4";
 import { loadCommands } from "./config.js";
 import { executeCommand } from "./executor.js";
-const CONFIG_PATH = process.env.EXO_COMMAND_FILE || "./.exocommand";
 // Subclass InMemoryTaskStore to abort running processes on task cancellation.
 // The SDK calls updateTaskStatus("cancelled") when a tasks/cancel request arrives.
 class ExoTaskStore extends InMemoryTaskStore {
@@ -24,7 +23,7 @@ class ExoTaskStore extends InMemoryTaskStore {
     }
 }
 async function runBackgroundExecution(params) {
-    const { taskId, commandName, command, cwd, signal, timeoutSignal, timeout, taskStore, server, logger, activeExecutions, } = params;
+    const { taskId, commandName, command, cwd, signal, timeoutSignal, timeout, taskStore, server, logger, activeExecutions, tui, } = params;
     const lines = [];
     let lineCount = 0;
     const log = async (level, loggerName, data) => {
@@ -56,6 +55,7 @@ async function runBackgroundExecution(params) {
                 // task may have been cleaned up
             }
             if (task?.status === "cancelled") {
+                tui?.updateExecution(taskId, "cancelled");
                 logger.warn("execute", `"${commandName}" was cancelled`);
                 return;
             }
@@ -63,6 +63,7 @@ async function runBackgroundExecution(params) {
             const status = timedOut
                 ? `Command "${commandName}" timed out after ${timeout}s.`
                 : `Command "${commandName}" was cancelled.`;
+            tui?.updateExecution(taskId, timedOut ? "timeout" : "cancelled");
             logger.warn("execute", `"${commandName}" ${timedOut ? "timed out" : "was cancelled"}`);
             await taskStore.storeTaskResult(taskId, "failed", {
                 content: [{
@@ -75,6 +76,7 @@ async function runBackgroundExecution(params) {
         }
         if (result.exitCode !== 0) {
             const status = `Command "${commandName}" exited with code ${result.exitCode}`;
+            tui?.updateExecution(taskId, "error");
             logger.error("execute", `"${commandName}" exited with code ${result.exitCode}`);
             await taskStore.storeTaskResult(taskId, "failed", {
                 content: [{
@@ -85,6 +87,7 @@ async function runBackgroundExecution(params) {
             });
             return;
         }
+        tui?.updateExecution(taskId, "success");
         logger.success("execute", `"${commandName}" completed (exit code 0)`);
         await taskStore.storeTaskResult(taskId, "completed", {
             content: [{
@@ -98,6 +101,7 @@ async function runBackgroundExecution(params) {
     catch (err) {
         const output = lines.join("\n");
         const status = `Command "${commandName}" failed: ${err.message}`;
+        tui?.updateExecution(taskId, "error");
         logger.error("execute", `"${commandName}" failed: ${err.message}`);
         await taskStore.storeTaskResult(taskId, "failed", {
             content: [{
@@ -124,7 +128,10 @@ export function createTaskContext(activeExecutions) {
         },
     };
 }
-export function registerTaskExecute(server, logger, activeExecutions) {
+export function registerTaskExecute(server, logger, activeExecutions, configPath, tui, agentId, projectKey) {
+    const resolvedTui = tui ?? null;
+    const resolvedAgentId = agentId ?? 0;
+    const resolvedProjectKey = projectKey ?? "";
     server.experimental.tasks.registerToolTask("execute", {
         title: "Execute Command",
         description: "Execute a predefined command by name. Streams stdout and stderr via logging notifications and task status updates.",
@@ -143,7 +150,7 @@ export function registerTaskExecute(server, logger, activeExecutions) {
             // Validate before creating a task — throw to fail without a zombie task
             let commands;
             try {
-                commands = await loadCommands(CONFIG_PATH);
+                commands = await loadCommands(configPath);
             }
             catch (err) {
                 throw new Error(`Error loading config: ${err.message}`);
@@ -159,6 +166,8 @@ export function registerTaskExecute(server, logger, activeExecutions) {
                     : 300_000,
                 pollInterval: 1000,
             });
+            // Notify TUI after task creation
+            resolvedTui?.addExecution(task.taskId, commandName, resolvedAgentId, resolvedProjectKey);
             // Compose abort signal from cancellation + optional timeout
             const ac = new AbortController();
             activeExecutions.set(task.taskId, ac);
@@ -187,6 +196,7 @@ export function registerTaskExecute(server, logger, activeExecutions) {
                 server,
                 logger,
                 activeExecutions,
+                tui: resolvedTui,
             }).catch(() => {
                 // errors are stored in the task store, not propagated here
             });