fix(session-management): reject mutually exclusive defaults in session-set-defaults via schema refine; fix exclusivePairs pruning to ignore null/undefined and not override session defaults; update tests

Author: cameroncooke

src/mcp/tools/session-management/__tests__/session_set_defaults.test.ts

@@ -88,5 +88,25 @@ describe('session-set-defaults tool', () => {
       expect(current.simulatorName).toBe('iPhone 16');
       expect(current.simulatorId).toBeUndefined();
     });
+
+    it('should reject when both projectPath and workspacePath are provided', async () => {
+      const res = await plugin.handler({
+        projectPath: '/app/App.xcodeproj',
+        workspacePath: '/app/App.xcworkspace',
+      });
+      expect(res.isError).toBe(true);
+      expect(res.content[0].text).toContain('Parameter validation failed');
+      expect(res.content[0].text).toContain('projectPath and workspacePath are mutually exclusive');
+    });
+
+    it('should reject when both simulatorId and simulatorName are provided', async () => {
+      const res = await plugin.handler({
+        simulatorId: 'SIM-1',
+        simulatorName: 'iPhone 16',
+      });
+      expect(res.isError).toBe(true);
+      expect(res.content[0].text).toContain('Parameter validation failed');
+      expect(res.content[0].text).toContain('simulatorId and simulatorName are mutually exclusive');
+    });
   });
 });

src/mcp/tools/session-management/session_set_defaults.ts

@@ -4,7 +4,7 @@ import { createTypedTool } from '../../../utils/typed-tool-factory.ts';
 import { getDefaultCommandExecutor } from '../../../utils/execution/index.ts';
 import type { ToolResponse } from '../../../types/common.ts';
 
-const schemaObj = z.object({
+const baseSchema = z.object({
   projectPath: z.string().optional(),
   workspacePath: z.string().optional(),
   scheme: z.string().optional(),
@@ -16,6 +16,16 @@ const schemaObj = z.object({
   arch: z.enum(['arm64', 'x86_64']).optional(),
 });
 
+const schemaObj = baseSchema
+  .refine((v) => !(v.projectPath && v.workspacePath), {
+    message: 'projectPath and workspacePath are mutually exclusive',
+    path: ['projectPath'],
+  })
+  .refine((v) => !(v.simulatorId && v.simulatorName), {
+    message: 'simulatorId and simulatorName are mutually exclusive',
+    path: ['simulatorId'],
+  });
+
 type Params = z.infer<typeof schemaObj>;
 
 export async function sessionSetDefaultsLogic(params: Params): Promise<ToolResponse> {
@@ -42,6 +52,6 @@ export default {
   name: 'session-set-defaults',
   description:
     'Set the session defaults needed by many tools. Most tools require one or more session defaults to be set before they can be used. Agents should set the relevant defaults at the beginning of a session.',
-  schema: schemaObj.shape,
+  schema: baseSchema.shape,
   handler: createTypedTool(schemaObj, sessionSetDefaultsLogic, getDefaultCommandExecutor),
 };

src/utils/__tests__/session-aware-tool-factory.test.ts

@@ -110,7 +110,7 @@ describe('createSessionAwareTool', () => {
     expect(result.content[0].text).toContain('Tip: set session defaults');
   });
 
-  it('exclusivePairs should prune conflicting session defaults when user provides null', async () => {
+  it('exclusivePairs should NOT prune session defaults when user provides null (treat as not provided)', async () => {
     const handlerWithExclusive = createSessionAwareTool<Params>({
       internalSchema,
       logicFunction: logic,
@@ -125,14 +125,15 @@ describe('createSessionAwareTool', () => {
     sessionStore.setDefaults({
       scheme: 'App',
       projectPath: '/path/proj.xcodeproj',
+      simulatorId: 'SIM-1',
     });
 
     const res = await handlerWithExclusive({ workspacePath: null as unknown as string });
-    expect(res.isError).toBe(true);
-    expect(res.content[0].text).toContain('Provide a project or workspace');
+    expect(res.isError).toBe(false);
+    expect(res.content[0].text).toBe('OK');
   });
 
-  it('exclusivePairs should prune when user provides undefined (key present)', async () => {
+  it('exclusivePairs should NOT prune when user provides undefined (key present)', async () => {
     const handlerWithExclusive = createSessionAwareTool<Params>({
       internalSchema,
       logicFunction: logic,
@@ -147,10 +148,11 @@ describe('createSessionAwareTool', () => {
     sessionStore.setDefaults({
       scheme: 'App',
       projectPath: '/path/proj.xcodeproj',
+      simulatorId: 'SIM-1',
     });
 
     const res = await handlerWithExclusive({ workspacePath: undefined as unknown as string });
-    expect(res.isError).toBe(true);
-    expect(res.content[0].text).toContain('Provide a project or workspace');
+    expect(res.isError).toBe(false);
+    expect(res.content[0].text).toBe('OK');
   });
 });

src/utils/typed-tool-factory.ts

@@ -89,19 +89,26 @@ export function createSessionAwareTool<TParams>(opts: {
 
   return async (rawArgs: Record<string, unknown>): Promise<ToolResponse> => {
     try {
+      // Sanitize args: treat null/undefined as "not provided" so they don't override session defaults
+      const sanitizedArgs: Record<string, unknown> = {};
+      for (const [k, v] of Object.entries(rawArgs)) {
+        if (v !== null && v !== undefined) sanitizedArgs[k] = v;
+      }
+
       // Start with session defaults merged with explicit args (args override session)
-      const merged: Record<string, unknown> = { ...sessionStore.getAll(), ...rawArgs };
+      const merged: Record<string, unknown> = { ...sessionStore.getAll(), ...sanitizedArgs };
 
-      // Apply exclusive pair pruning: if caller provided/touched any key in a pair (even null/undefined),
-      // remove other keys from that pair which came only from session defaults (not explicitly provided).
-      // This ensures requirements and validation reflect the effective, post-prune payload.
+      // Apply exclusive pair pruning: only when caller provided a concrete (non-null/undefined) value
+      // for any key in the pair. When activated, drop other keys in the pair coming from session defaults.
       for (const pair of exclusivePairs) {
-        const userTouched = pair.some((k) => Object.prototype.hasOwnProperty.call(rawArgs, k));
-        if (userTouched) {
-          for (const k of pair) {
-            if (rawArgs[k] == null && merged[k] != null) {
-              delete merged[k];
-            }
+        const userProvidedConcrete = pair.some((k) =>
+          Object.prototype.hasOwnProperty.call(sanitizedArgs, k),
+        );
+        if (!userProvidedConcrete) continue;
+
+        for (const k of pair) {
+          if (!Object.prototype.hasOwnProperty.call(sanitizedArgs, k) && k in merged) {
+            delete merged[k];
           }
         }
       }