XC-MCP: XCode CLI wrapper

Instructions

Implementation Reference

• src/tools/persistence/disable.ts:62-124 (handler)

  The handler function that implements the persistence-disable tool logic. It handles the disable operation, optionally clears data, interacts with persistenceManager, and returns structured JSON response.

  export async function persistenceDisableTool(args: any): Promise<ToolResult> {
    try {
      const { clearData = false } = args as PersistenceDisableArgs;
  
      if (!persistenceManager.isEnabled()) {
        return {
          content: [
            {
              type: 'text' as const,
              text: JSON.stringify(
                {
                  success: false,
                  message: 'Persistence is already disabled',
                  clearData: false,
                },
                null,
                2
              ),
            },
          ],
        };
      }
  
      // Get storage info before disabling (if data is being cleared)
      const storageInfo = clearData ? await persistenceManager.getStatus(true) : null;
  
      const result = await persistenceManager.disable(clearData);
  
      if (result.success) {
        return {
          content: [
            {
              type: 'text' as const,
              text: JSON.stringify(
                {
                  success: true,
                  message: result.message,
                  clearedData: clearData,
                  previousStorageInfo: storageInfo?.storageInfo || null,
                  effect: 'XC-MCP will now operate with in-memory caching only',
                },
                null,
                2
              ),
            },
          ],
        };
      } else {
        throw new McpError(
          ErrorCode.InternalError,
          `Failed to disable persistence: ${result.message}`
        );
      }
    } catch (error) {
      if (error instanceof McpError) {
        throw error;
      }
      throw new McpError(
        ErrorCode.InternalError,
        `Failed to disable persistence: ${error instanceof Error ? error.message : String(error)}`
      );
    }
  }

• src/tools/persistence/disable.ts:5-7 (schema)

  Input schema/type definition for the persistence-disable tool arguments.

  interface PersistenceDisableArgs {
    clearData?: boolean;
  }

• src/tools/persistence/index.ts:69-71 (helper)

  Routing logic in the consolidated 'persistence' tool that delegates to the disable handler when operation='disable'.

  case 'disable':
    return persistenceDisableTool({ clearData: args.clearData ?? false });
  case 'status':

• src/registry/cache.ts:49-75 (registration)

  Registration of the consolidated 'persistence' tool, which handles 'persistence-disable' functionality via operation='disable'. Backwards compatibility docs reference 'persistence-disable'.

    server.registerTool(
      'persistence',
      {
        description: getDescription(PERSISTENCE_DOCS, PERSISTENCE_DOCS_MINI),
        inputSchema: {
          operation: z.enum(['enable', 'disable', 'status']),
          cacheDir: z.string().optional(),
          clearData: z.boolean().default(false),
          includeStorageInfo: z.boolean().default(true),
        },
        ...DEFER_LOADING_CONFIG,
      },
      async args => {
        try {
          await validateXcodeInstallation();
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          return (await persistenceTool(args)) as any;
        } catch (error) {
          if (error instanceof McpError) throw error;
          throw new McpError(
            ErrorCode.InternalError,
            `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`
          );
        }
      }
    );
  }

• src/tools/persistence/disable.ts:126-166 (helper)

  Documentation string for the persistence-disable tool.

  export const PERSISTENCE_DISABLE_DOCS = `
  # persistence-disable
  
  🔌 **Disable persistent state management and return to in-memory-only caching** - Turn off persistence.
  
  Safely deactivates file-based persistence and optionally deletes existing cache data files. After disabling, XC-MCP operates with in-memory caching only, losing all learned state on server restart. Useful for privacy requirements, disk space constraints, or troubleshooting cache-related issues.
  
  ## Advantages
  
  • Meet privacy requirements that prohibit persistent storage
  • Free up disk space when storage is limited
  • Switch to CI/CD mode where persistence isn't beneficial
  • Troubleshoot issues potentially caused by stale cached data
  
  ## Parameters
  
  ### Required
  - (None)
  
  ### Optional
  - clearData (boolean): Whether to delete existing cache files when disabling. Defaults to false
  
  ## Returns
  
  - Tool execution results with persistence deactivation confirmation
  - Confirmation of whether cache files were cleared
  - Previous storage information (if clearData was true)
  - Operational effect description
  
  ## Related Tools
  
  - persistence-enable: Turn on persistence
  - persistence-status: View persistence system status
  
  ## Notes
  
  - Tool is auto-registered with MCP server
  - Defaults to keeping cache files (just stopping writes)
  - Set clearData: true to delete all cache files
  - Operation is immediate and irreversible
  `;