simplify internal structures.

bhouston · bhouston · commit e40b0a2317f1 · 2025-02-10T12:26:16.000-05:00
diff --git a/src/tools/system/shellMessage.test.ts b/src/tools/system/shellMessage.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { shellStartTool } from "./shellStart.js";
+import { processStates, shellStartTool } from "./shellStart.js";
 import { MockLogger } from "../../utils/mockLogger.js";
 import { shellMessageTool } from "./shellMessage.js";
 
@@ -10,14 +10,14 @@ describe("shellMessageTool", () => {
   let testInstanceId = "";
 
   beforeEach(() => {
-    global.startedProcesses.clear();
+    processStates.clear();
   });
 
   afterEach(() => {
-    for (const process of global.startedProcesses.values()) {
-      process.kill();
+    for (const processState of processStates.values()) {
+      processState.process.kill();
     }
-    global.startedProcesses.clear();
+    processStates.clear();
   });
 
   it("should interact with a running process", async () => {
@@ -82,8 +82,8 @@ describe("shellMessageTool", () => {
     );
 
     expect(result.completed).toBe(true);
-    // Process should still be in startedProcesses even after completion
-    expect(global.startedProcesses.has(startResult.instanceId)).toBe(true);
+    // Process should still be in processStates even after completion
+    expect(processStates.has(startResult.instanceId)).toBe(true);
   });
 
   it("should handle SIGTERM signal correctly", async () => {
@@ -179,10 +179,8 @@ describe("shellMessageTool", () => {
       { logger: mockLogger }
     );
 
-    console.log({ checkResult });
-
     expect(checkResult.signaled).toBe(true);
     expect(checkResult.completed).toBe(true);
-    expect(global.startedProcesses.has(startResult.instanceId)).toBe(true);
+    expect(processStates.has(startResult.instanceId)).toBe(true);
   });
 });
diff --git a/src/tools/system/shellMessage.ts b/src/tools/system/shellMessage.ts
@@ -1,56 +1,87 @@
 import { Tool } from "../../core/types.js";
 import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
+import { processStates } from "./shellStart.js";
 
 // Define valid NodeJS signals as a union type
 type NodeSignals =
-  | 'SIGABRT'
-  | 'SIGALRM'
-  | 'SIGBUS'
-  | 'SIGCHLD'
-  | 'SIGCONT'
-  | 'SIGFPE'
-  | 'SIGHUP'
-  | 'SIGILL'
-  | 'SIGINT'
-  | 'SIGIO'
-  | 'SIGIOT'
-  | 'SIGKILL'
-  | 'SIGPIPE'
-  | 'SIGPOLL'
-  | 'SIGPROF'
-  | 'SIGPWR'
-  | 'SIGQUIT'
-  | 'SIGSEGV'
-  | 'SIGSTKFLT'
-  | 'SIGSTOP'
-  | 'SIGSYS'
-  | 'SIGTERM'
-  | 'SIGTRAP'
-  | 'SIGTSTP'
-  | 'SIGTTIN'
-  | 'SIGTTOU'
-  | 'SIGUNUSED'
-  | 'SIGURG'
-  | 'SIGUSR1'
-  | 'SIGUSR2'
-  | 'SIGVTALRM'
-  | 'SIGWINCH'
-  | 'SIGXCPU'
-  | 'SIGXFSZ';
+  | "SIGABRT"
+  | "SIGALRM"
+  | "SIGBUS"
+  | "SIGCHLD"
+  | "SIGCONT"
+  | "SIGFPE"
+  | "SIGHUP"
+  | "SIGILL"
+  | "SIGINT"
+  | "SIGIO"
+  | "SIGIOT"
+  | "SIGKILL"
+  | "SIGPIPE"
+  | "SIGPOLL"
+  | "SIGPROF"
+  | "SIGPWR"
+  | "SIGQUIT"
+  | "SIGSEGV"
+  | "SIGSTKFLT"
+  | "SIGSTOP"
+  | "SIGSYS"
+  | "SIGTERM"
+  | "SIGTRAP"
+  | "SIGTSTP"
+  | "SIGTTIN"
+  | "SIGTTOU"
+  | "SIGUNUSED"
+  | "SIGURG"
+  | "SIGUSR1"
+  | "SIGUSR2"
+  | "SIGVTALRM"
+  | "SIGWINCH"
+  | "SIGXCPU"
+  | "SIGXFSZ";
 
 const parameterSchema = z.object({
   instanceId: z.string().describe("The ID returned by shellStart"),
   stdin: z.string().optional().describe("Input to send to process"),
-  signal: z.enum([
-    'SIGABRT', 'SIGALRM', 'SIGBUS', 'SIGCHLD', 'SIGCONT',
-    'SIGFPE', 'SIGHUP', 'SIGILL', 'SIGINT', 'SIGIO',
-    'SIGIOT', 'SIGKILL', 'SIGPIPE', 'SIGPOLL', 'SIGPROF',
-    'SIGPWR', 'SIGQUIT', 'SIGSEGV', 'SIGSTKFLT', 'SIGSTOP',
-    'SIGSYS', 'SIGTERM', 'SIGTRAP', 'SIGTSTP', 'SIGTTIN',
-    'SIGTTOU', 'SIGUNUSED', 'SIGURG', 'SIGUSR1', 'SIGUSR2',
-    'SIGVTALRM', 'SIGWINCH', 'SIGXCPU', 'SIGXFSZ'
-  ] as const).optional().describe("Signal to send to the process (e.g., SIGTERM, SIGINT)"),
+  signal: z
+    .enum([
+      "SIGABRT",
+      "SIGALRM",
+      "SIGBUS",
+      "SIGCHLD",
+      "SIGCONT",
+      "SIGFPE",
+      "SIGHUP",
+      "SIGILL",
+      "SIGINT",
+      "SIGIO",
+      "SIGIOT",
+      "SIGKILL",
+      "SIGPIPE",
+      "SIGPOLL",
+      "SIGPROF",
+      "SIGPWR",
+      "SIGQUIT",
+      "SIGSEGV",
+      "SIGSTKFLT",
+      "SIGSTOP",
+      "SIGSYS",
+      "SIGTERM",
+      "SIGTRAP",
+      "SIGTSTP",
+      "SIGTTIN",
+      "SIGTTOU",
+      "SIGUNUSED",
+      "SIGURG",
+      "SIGUSR1",
+      "SIGUSR2",
+      "SIGVTALRM",
+      "SIGWINCH",
+      "SIGXCPU",
+      "SIGXFSZ",
+    ] as const)
+    .optional()
+    .describe("Signal to send to the process (e.g., SIGTERM, SIGINT)"),
   description: z
     .string()
     .max(80)
@@ -79,60 +110,53 @@ export const shellMessageTool: Tool<Parameters, ReturnType> = {
   parameters: zodToJsonSchema(parameterSchema),
   returns: zodToJsonSchema(returnSchema),
 
-  execute: async ({ instanceId, stdin, signal }, { logger }): Promise<ReturnType> => {
+  execute: async (
+    { instanceId, stdin, signal },
+    { logger }
+  ): Promise<ReturnType> => {
     logger.verbose(
       `Interacting with shell process ${instanceId}${stdin ? " with input" : ""}${signal ? ` with signal ${signal}` : ""}`
     );
 
     try {
-      const process = global.startedProcesses.get(instanceId);
-      if (!process) {
-        throw new Error(`No process found with ID ${instanceId}`);
-      }
-
-      const processOutput = global.processOutputs.get(instanceId);
-      if (!processOutput) {
-        throw new Error(`No output buffers found for process ${instanceId}`);
-      }
-
-      const processState = global.processState.get(instanceId);
+      const processState = processStates.get(instanceId);
       if (!processState) {
-        throw new Error(`No state information found for process ${instanceId}`);
+        throw new Error(`No process found with ID ${instanceId}`);
       }
 
       // Send signal if provided
       if (signal) {
-        const wasKilled = process.kill(signal);
+        const wasKilled = processState.process.kill(signal);
         if (!wasKilled) {
           return {
             stdout: "",
             stderr: "",
-            completed: processState.completed,
+            completed: processState.state.completed,
             signaled: false,
-            error: `Failed to send signal ${signal} to process (process may have already terminated)`
+            error: `Failed to send signal ${signal} to process (process may have already terminated)`,
           };
         }
-        processState.signaled = true;
+        processState.state.signaled = true;
       }
 
       // Send input if provided
       if (stdin) {
-        if (!process.stdin?.writable) {
+        if (!processState.process.stdin?.writable) {
           throw new Error("Process stdin is not available");
         }
-        process.stdin.write(`${stdin}\n`);
+        processState.process.stdin.write(`${stdin}\n`);
       }
 
       // Wait a brief moment for output to be processed
       await new Promise((resolve) => setTimeout(resolve, 100));
 
       // Get accumulated output
-      const stdout = processOutput.stdout.join("");
-      const stderr = processOutput.stderr.join("");
+      const stdout = processState.stdout.join("");
+      const stderr = processState.stderr.join("");
 
       // Clear the buffers
-      processOutput.stdout = [];
-      processOutput.stderr = [];
+      processState.stdout = [];
+      processState.stderr = [];
 
       logger.verbose("Interaction completed successfully");
       if (stdout) {
@@ -145,8 +169,8 @@ export const shellMessageTool: Tool<Parameters, ReturnType> = {
       return {
         stdout: stdout.trim(),
         stderr: stderr.trim(),
-        completed: processState.completed,
-        signaled: processState.signaled,
+        completed: processState.state.completed,
+        signaled: processState.state.signaled,
       };
     } catch (error) {
       if (error instanceof Error) {
diff --git a/src/tools/system/shellStart.test.ts b/src/tools/system/shellStart.test.ts
@@ -1,26 +1,26 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { shellStartTool } from './shellStart.js';
-import { MockLogger } from '../../utils/mockLogger.js';
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { processStates, shellStartTool } from "./shellStart.js";
+import { MockLogger } from "../../utils/mockLogger.js";
 
-describe('shellStartTool', () => {
+describe("shellStartTool", () => {
   const mockLogger = new MockLogger();
 
   beforeEach(() => {
-    global.startedProcesses.clear();
+    processStates.clear();
   });
 
   afterEach(() => {
-    for (const process of global.startedProcesses.values()) {
-      process.kill();
+    for (const processState of processStates.values()) {
+      processState.process.kill();
     }
-    global.startedProcesses.clear();
+    processStates.clear();
   });
 
-  it('should start a process and return instance ID', async () => {
+  it("should start a process and return instance ID", async () => {
     const result = await shellStartTool.execute(
       {
         command: 'echo "test"',
-        description: 'Test process',
+        description: "Test process",
       },
       { logger: mockLogger }
     );
@@ -29,65 +29,65 @@ describe('shellStartTool', () => {
     expect(result.error).toBeUndefined();
   });
 
-  it('should handle invalid commands', async () => {
+  it("should handle invalid commands", async () => {
     const result = await shellStartTool.execute(
       {
-        command: 'nonexistentcommand',
-        description: 'Invalid command test',
+        command: "nonexistentcommand",
+        description: "Invalid command test",
       },
       { logger: mockLogger }
     );
 
     expect(result.error).toBeDefined();
   });
 
-  it('should keep process in startedProcesses after completion', async () => {
+  it("should keep process in processStates after completion", async () => {
     const result = await shellStartTool.execute(
       {
         command: 'echo "test"',
-        description: 'Completion test',
+        description: "Completion test",
       },
       { logger: mockLogger }
     );
 
     // Wait for process to complete
-    await new Promise(resolve => setTimeout(resolve, 100));
+    await new Promise((resolve) => setTimeout(resolve, 100));
 
-    // Process should still be in startedProcesses
-    expect(global.startedProcesses.has(result.instanceId)).toBe(true);
+    // Process should still be in processStates
+    expect(processStates.has(result.instanceId)).toBe(true);
   });
 
-  it('should handle piped commands correctly', async () => {
+  it("should handle piped commands correctly", async () => {
     // Start a process that uses pipes
     const result = await shellStartTool.execute(
       {
-        command: 'grep "test"',  // Just grep waiting for stdin
-        description: 'Pipe test',
+        command: 'grep "test"', // Just grep waiting for stdin
+        description: "Pipe test",
       },
       { logger: mockLogger }
     );
 
     expect(result.instanceId).toBeDefined();
     expect(result.error).toBeUndefined();
 
-    // Process should be in startedProcesses
-    expect(global.startedProcesses.has(result.instanceId)).toBe(true);
+    // Process should be in processStates
+    expect(processStates.has(result.instanceId)).toBe(true);
 
     // Get the process
-    const process = global.startedProcesses.get(result.instanceId);
-    expect(process).toBeDefined();
-    
+    const processState = processStates.get(result.instanceId);
+    expect(processState).toBeDefined();
+
     // Write to stdin and check output
-    if (process?.stdin) {
-      process.stdin.write('this is a test line\n');
-      process.stdin.write('not matching line\n');
-      process.stdin.write('another test here\n');
-      
+    if (processState?.process.stdin) {
+      processState.process.stdin.write("this is a test line\n");
+      processState.process.stdin.write("not matching line\n");
+      processState.process.stdin.write("another test here\n");
+
       // Wait for output
-      await new Promise(resolve => setTimeout(resolve, 200));
-      
+      await new Promise((resolve) => setTimeout(resolve, 200));
+
       // Process should have filtered only lines with "test"
       // This part might need adjustment based on how output is captured
     }
   });
-});
+});
diff --git a/src/tools/system/shellStart.ts b/src/tools/system/shellStart.ts
